@sparkelf/dsh-dataops-managed 0.3.19 → 0.3.21

package/lib/index.js

@@ -1,9 +1,34 @@
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import * as McpClient from "@sparkelf/dsh-plugin-mcp-credentials";
 import { BUNDLED_SKILL_RANK } from "@deepseek-ai/dsh-skill";
 import z from "@deepseek-ai/schemastery";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+//#region src/auth-state.ts
+let state = "unknown";
+/**
+* Record that a DataOps call was accepted.
+*
+* Called on any non-401 answer, including ones that carry a refusal for another reason: a 403
+* says the session is fine and the permission is not, so it must not raise the sign-in prompt.
+*/
+const noteAccepted = () => {
+	state = "valid";
+};
+/** Record that DataOps refused the credential, which means the session is over. */
+const noteExpired = () => {
+	state = "expired";
+};
+/**
+* Read the current observation.
+*
+* @returns `unknown` before any call has completed, then what the last one said.
+*/
+const currentAuthState = () => state;
+//#endregion
 //#region src/model-settings.ts
 /** Profile entry id whose Config holds the model providers. */
 const MODEL_SETTINGS_NAMESPACE = "llm-pi-ai";
@@ -191,7 +216,11 @@ var ModelSync = class {
 			method: "POST",
 			headers: { authorization: `Bearer ${token}` }
 		});
-		if (response.status === 401) return void 0;
+		if (response.status === 401) {
+			noteExpired();
+			return;
+		}
+		noteAccepted();
 		if (!response.ok) throw new Error(`Shared model read failed with HTTP ${String(response.status)}`);
 		const body = asRecord$3(await response.json());
 		if (body === null) return void 0;
@@ -258,7 +287,11 @@ var ModelSync = class {
 		const token = await this.token();
 		if (token === void 0) return null;
 		const response = await fetch(new URL("/api/ai/shared-models/publication", this.apiBase()), { headers: { authorization: `Bearer ${token}` } });
-		if (response.status === 401) return null;
+		if (response.status === 401) {
+			noteExpired();
+			return null;
+		}
+		noteAccepted();
 		if (!response.ok) throw new Error(`Shared model status read failed with HTTP ${String(response.status)}`);
 		const body = asRecord$3(await response.json());
 		return {
@@ -605,7 +638,11 @@ var SkillPlaza = class {
 				...init.headers
 			}
 		});
-		if (response.status === 401) return void 0;
+		if (response.status === 401) {
+			noteExpired();
+			return;
+		}
+		noteAccepted();
 		if (!response.ok) throw new Error(`Skill plaza request failed with HTTP ${String(response.status)}`);
 		return response.status === 204 ? null : await response.json();
 	}
@@ -615,13 +652,30 @@ var SkillPlaza = class {
 	* @returns Entries, newest first; empty when the workspace is not authorized.
 	*/
 	async list(options = {}) {
+		return (await this.listPage(options)).skills;
+	}
+	/** List with the server's tab counts, which the plaza shows without re-counting a page. */
+	async listPage(options = {}) {
 		const params = new URLSearchParams();
 		if (options.tag !== void 0 && options.tag !== "") params.set("tag", options.tag);
 		if (options.query !== void 0 && options.query !== "") params.set("q", options.query);
+		if (options.status !== void 0 && options.status !== "") params.set("status", options.status);
+		if (options.scope !== void 0 && options.scope !== "") params.set("scope", options.scope);
+		if (options.departmentCode !== void 0 && options.departmentCode !== "") params.set("departmentCode", options.departmentCode);
 		const suffix = params.size === 0 ? "" : `?${params.toString()}`;
 		const body = await this.call(`/api/ai/skill-plaza/skills${suffix}`);
-		if (!Array.isArray(body)) return [];
-		return body.flatMap((row) => this.toPlazaSkill(row));
+		const record = asRecord$1(body);
+		const rows = Array.isArray(body) ? body : Array.isArray(record?.items) ? record.items : [];
+		const rawCounts = asRecord$1(record?.counts);
+		return {
+			skills: rows.flatMap((row) => this.toPlazaSkill(row)),
+			...rawCounts === null ? {} : { counts: {
+				pending: Number(rawCounts.pending ?? 0),
+				approved: Number(rawCounts.approved ?? 0),
+				rejected: Number(rawCounts.rejected ?? 0),
+				total: Number(rawCounts.total ?? rows.length)
+			} }
+		};
 	}
 	/**
 	* Every tag in use, so the browser offers existing labels.
@@ -680,11 +734,583 @@ var SkillPlaza = class {
 			instruction: typeof row.instruction === "string" ? row.instruction : "",
 			tags: Array.isArray(row.tags) ? row.tags.filter((tag) => typeof tag === "string") : [],
 			sharedByMe: row.sharedByMe === true,
-			updatedAt: typeof row.updatedAt === "string" ? row.updatedAt : ""
+			updatedAt: typeof row.updatedAt === "string" ? row.updatedAt : "",
+			reviewStatus: row.reviewStatus === "pending" || row.reviewStatus === "rejected" ? row.reviewStatus : "approved",
+			visibility: row.visibility === "department" || row.visibility === "private" ? row.visibility : "global",
+			departmentCode: typeof row.departmentCode === "string" ? row.departmentCode : null,
+			departmentName: typeof row.departmentName === "string" ? row.departmentName : void 0,
+			departmentPath: Array.isArray(row.departmentPath) ? row.departmentPath.flatMap((entry) => {
+				const node = asRecord$1(entry);
+				return node !== null && typeof node.name === "string" ? [{
+					code: typeof node.code === "string" ? node.code : "",
+					name: node.name
+				}] : [];
+			}) : void 0,
+			ownerName: typeof row.ownerName === "string" ? row.ownerName : void 0,
+			riskReport: row.riskReport ?? null,
+			reviewNote: typeof row.reviewNote === "string" ? row.reviewNote : null,
+			submittedAt: typeof row.submittedAt === "string" ? row.submittedAt : void 0
 		}];
 	}
 };
 //#endregion
+//#region src/review-api.ts
+/** Cookie-free same-origin bridge to the review endpoints. */
+var ReviewApi = class {
+	ctx;
+	config;
+	constructor(ctx, config) {
+		this.ctx = ctx;
+		this.config = config;
+	}
+	apiBase() {
+		return new URL(this.config.baseUrl).origin;
+	}
+	async token() {
+		return (await this.ctx.credentials.resolve(credentialRef(this.config.credentialRef)))?.value;
+	}
+	/**
+	* Call one DataOps endpoint with the workspace JWT.
+	* @param path - API path below the DataOps origin.
+	* @param init - Method, body and extra headers.
+	* @returns The upstream status and parsed body; 503 when this workspace has no session.
+	*/
+	async request(path, init = {}) {
+		const token = await this.token();
+		if (token === void 0) return {
+			status: 503,
+			body: { error: "DataOps is not connected" }
+		};
+		const response = await fetch(new URL(path, this.apiBase()), {
+			...init,
+			headers: {
+				authorization: `Bearer ${token}`,
+				...init.body === void 0 ? {} : { "content-type": "application/json" },
+				...init.headers
+			}
+		});
+		if (response.status === 401) {
+			noteExpired();
+			return {
+				status: 401,
+				body: { error: "DataOps session expired" }
+			};
+		}
+		noteAccepted();
+		const text = await response.text();
+		let body = null;
+		if (text !== "") try {
+			body = JSON.parse(text);
+		} catch {
+			body = { error: text };
+		}
+		return {
+			status: response.status,
+			body
+		};
+	}
+};
+//#endregion
+//#region src/tools.ts
+const open = {
+	type: "object",
+	additionalProperties: true
+};
+const render = (_args, value) => [{
+	type: "text",
+	text: JSON.stringify(value, null, 2)
+}];
+const roleSet = (scope) => new Set(scope.roleCodes ?? []);
+const isSuper = (scope) => roleSet(scope).has("超级管理员") || scope.primaryRole === "超级管理员";
+const isAdmin = (scope) => isSuper(scope) || roleSet(scope).has("管理员") || scope.primaryRole === "管理员";
+const isDeptAdmin = (scope) => roleSet(scope).has("部门管理员") || scope.primaryRole === "部门管理员";
+const canReview = (scope) => scope.review?.canReview === true || isAdmin(scope) || isDeptAdmin(scope);
+const forbidden = (message) => /* @__PURE__ */ new Error("Forbidden (403): " + message);
+/** Permission codes from the context, tolerating either field name during rollout. */
+const permissionsOf = (scope) => new Set(scope.permissions ?? scope.permissionKeys ?? []);
+/**
+* Whether the caller holds one `skill:*` capability.
+*
+* The context is the authority once it carries a permission list; before task-70 ships,
+* the role-name fallback keeps the existing four-role behavior. A present-but-empty list is
+* a denial, not a reason to fall back: an authenticated user with no keys must not inherit
+* administrator powers from their role label alone.
+*/
+const hasSkillPermission = (scope, key) => {
+	const permissions = permissionsOf(scope);
+	if (scope.permissions !== void 0 || scope.permissionKeys !== void 0) return permissions.has(key);
+	if (isAdmin(scope)) return true;
+	if (isDeptAdmin(scope)) return key !== "skill:review:global";
+	return key === "skill:read" || key === "skill:install" || key === "skill:submit";
+};
+const requireSkillPermission = (scope, key) => {
+	if (!hasSkillPermission(scope, key)) throw forbidden("missing permission " + key);
+};
+/** Fetch and validate the caller's DataOps scope. */
+async function loadScope(api) {
+	const result = await api.request("/api/ai/review/context");
+	if (result.status === 401) throw new Error("Unauthorized (401): DataOps session expired");
+	if (result.status === 403) throw forbidden("no review context");
+	if (result.status !== 200) throw new Error("review context failed: HTTP " + result.status.toString());
+	const body = result.body;
+	if (body === null || typeof body.roleCodes !== "object" || !Array.isArray(body.roleCodes)) throw new Error("review context is missing roleCodes");
+	return body;
+}
+/** Parse one plaza response body into rows without trusting its shape. */
+function rowsOf(body) {
+	if (Array.isArray(body)) return body.filter((row) => typeof row === "object" && row !== null);
+	if (typeof body === "object" && body !== null && Array.isArray(body.skills)) return body.skills.filter((row) => typeof row === "object" && row !== null);
+	return [];
+}
+/** Register the skill-centre and review tools. */
+function registerAiManagementTools(ctx, reviewApi) {
+	const disposers = [];
+	const register = (tool) => {
+		disposers.push(ctx.tools.register(tool));
+	};
+	const approve = async (tool, exec, reason) => {
+		if (exec.agent === void 0) throw new Error(tool + " requires an initiating agent");
+		const outcome = await ctx.approval.request({
+			agent: exec.agent,
+			toolName: tool,
+			callId: exec.callId,
+			signal: exec.signal,
+			reason
+		});
+		if (outcome !== "allowed-once") throw new Error(tool + " approval was " + outcome);
+	};
+	const audit = (tool, exec, detail) => {
+		try {
+			const agent = exec.agent;
+			ctx.logger.info("[audit] " + tool + " " + JSON.stringify({
+				sessionId: agent?.session?.id ?? null,
+				callId: exec.callId,
+				...detail
+			}));
+		} catch {}
+	};
+	const call = async (path, init = {}) => {
+		const result = await reviewApi.request(path, init);
+		if (result.status === 401) throw new Error("Unauthorized (401): DataOps session expired");
+		const detail = result.body;
+		const reason = typeof detail?.error === "string" ? detail.error : typeof detail?.message === "string" ? detail.message : "";
+		if (result.status === 403) throw forbidden(reason || "the current role may not perform this action");
+		if (result.status === 409) throw new Error("Conflict (409): " + (reason || "the skill still has installations"));
+		if (result.status < 200 || result.status >= 300) throw new Error("DataOps " + path + " failed: HTTP " + result.status.toString() + (reason ? ": " + reason : ""));
+		return result.body;
+	};
+	const listSkills = async (scope, includeLocal) => {
+		requireSkillPermission(scope, "skill:read");
+		const mine = rowsOf(await call("/api/ai/skill-plaza/skills?scope=mine"));
+		const publicRows = rowsOf(await call("/api/ai/skill-plaza/skills"));
+		const admin = isAdmin(scope) ? rowsOf(await call("/api/ai/skill-plaza/admin/skills")) : [];
+		const byId = /* @__PURE__ */ new Map();
+		for (const row of [
+			...mine,
+			...publicRows,
+			...admin
+		]) if (typeof row.id === "number") byId.set(row.id, {
+			...byId.get(row.id),
+			...row
+		});
+		const rows = [...byId.values()];
+		return {
+			catalog: {
+				local: includeLocal ? (await readLocalSkills(ctx)).map((skill) => ({
+					name: skill.name,
+					description: skill.description ?? null,
+					source: "local"
+				})) : [],
+				pending: rows.filter((row) => row.reviewStatus === "pending"),
+				approved: rows.filter((row) => row.reviewStatus === "approved"),
+				rejected: rows.filter((row) => row.reviewStatus === "rejected")
+			},
+			canReview: canReview(scope),
+			isAdmin: isAdmin(scope),
+			isDepartmentAdmin: isDeptAdmin(scope),
+			departmentCode: scope.departmentCode ?? null,
+			skills: rows
+		};
+	};
+	register(defineTool({
+		name: "skill_list",
+		description: "List skills in the DataOps skill centre: local workspace skills plus the caller's pending/rejected submissions and the approved plaza entries they may install. Scope follows the caller role (department admins see their department; ordinary users see their own and approved entries). Read-only.",
+		parameters: { include_local: {
+			type: "boolean",
+			description: "Include local workspace skills (default true)."
+		} },
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args) => {
+			const scope = await loadScope(reviewApi);
+			return listSkills(scope, args.include_local !== false);
+		}
+	}));
+	register(defineTool({
+		name: "skill_get",
+		description: "Read one skill-centre entry by id: description, instruction, review status, review note, risk report and visibility. Only entries visible to the caller can be read.",
+		parameters: { skill_id: {
+			type: "number",
+			required: true,
+			description: "Skill/plaza id from skill_list."
+		} },
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args) => {
+			const scope = await loadScope(reviewApi);
+			const found = (await listSkills(scope, false)).skills.find((row) => row.id === args.skill_id);
+			if (found === void 0) throw new Error("Skill not found or not visible: " + args.skill_id.toString());
+			return found;
+		}
+	}));
+	register(defineTool({
+		name: "skill_submit",
+		description: "Submit the caller's own skill for plaza review. When the workspace review switch is off DataOps approves immediately; otherwise the entry becomes pending. Requires user approval; audited.",
+		parameters: { skill_id: {
+			type: "number",
+			required: true,
+			description: "Own skill/plaza id."
+		} },
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args, exec) => {
+			const scope = await loadScope(reviewApi);
+			requireSkillPermission(scope, "skill:submit");
+			await approve("skill_submit", exec, "Submit skill " + args.skill_id.toString() + " for review");
+			const value = await call("/api/ai/skill-plaza/skills/" + args.skill_id.toString() + "/submit", {
+				method: "POST",
+				body: "{}"
+			});
+			audit("skill_submit", exec, { skillId: args.skill_id });
+			return value;
+		}
+	}));
+	register(defineTool({
+		name: "skill_install",
+		description: "Install one approved, visible plaza skill into the caller's workspace. Requires user approval; audited. The secret-free result reports the local skill key.",
+		parameters: { skill_id: {
+			type: "number",
+			required: true,
+			description: "Plaza skill id."
+		} },
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args, exec) => {
+			const scope = await loadScope(reviewApi);
+			requireSkillPermission(scope, "skill:install");
+			await approve("skill_install", exec, "Install skill " + args.skill_id.toString());
+			const value = await call("/api/ai/skill-plaza/install", {
+				method: "POST",
+				body: JSON.stringify({ skillId: args.skill_id })
+			});
+			audit("skill_install", exec, { skillId: args.skill_id });
+			return value;
+		}
+	}));
+	register(defineTool({
+		name: "skill_uninstall",
+		description: "Uninstall one skill from the caller's own workspace only: deletes the current user's installation record. The plaza entry, its review status, visibility and enabled flag are unchanged and no “unpublished” notification is sent. Requires user approval; audited.",
+		parameters: { skill_id: {
+			type: "number",
+			required: true,
+			description: "Plaza skill id."
+		} },
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args, exec) => {
+			const scope = await loadScope(reviewApi);
+			requireSkillPermission(scope, "skill:install");
+			await approve("skill_uninstall", exec, "Uninstall skill " + args.skill_id.toString() + " from the current workspace");
+			const result = await call("/api/ai/skill-plaza/skills/" + args.skill_id.toString() + "/install", { method: "DELETE" });
+			audit("skill_uninstall", exec, {
+				skillId: args.skill_id,
+				scope: "installation-only",
+				removed: result.removed ?? null
+			});
+			return {
+				uninstalled: result.uninstalled === true,
+				removed: typeof result.removed === "number" ? result.removed : 0
+			};
+		}
+	}));
+	const setEnabled = (enabled) => defineTool({
+		name: enabled ? "skill_enable" : "skill_disable",
+		description: (enabled ? "Enable" : "Disable") + " one plaza skill for distribution. Administrator only. Requires user approval; audited.",
+		parameters: { skill_id: {
+			type: "number",
+			required: true,
+			description: "Plaza skill id."
+		} },
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args, exec) => {
+			const scope = await loadScope(reviewApi);
+			requireSkillPermission(scope, "skill:manage");
+			await approve(enabled ? "skill_enable" : "skill_disable", exec, (enabled ? "Enable" : "Disable") + " skill " + args.skill_id.toString());
+			await call("/api/ai/skill-plaza/admin/skills/" + args.skill_id.toString() + "/status", {
+				method: "PATCH",
+				body: JSON.stringify({ enabled })
+			});
+			audit(enabled ? "skill_enable" : "skill_disable", exec, {
+				skillId: args.skill_id,
+				enabled
+			});
+			return {
+				skillId: args.skill_id,
+				enabled
+			};
+		}
+	});
+	register(setEnabled(true));
+	register(setEnabled(false));
+	register(defineTool({
+		name: "skill_unshare",
+		description: "Stop sharing one plaza skill (soft unpublish): the entry and its installations remain, review status/visibility are kept, and DataOps sends an “unpublished” notification. Owners may unshare their own entries; 超级管理员/管理员 any entry; 部门管理员 their department. Requires user approval; audited.",
+		parameters: { skill_id: {
+			type: "number",
+			required: true,
+			description: "Plaza skill id."
+		} },
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args, exec) => {
+			const scope = await loadScope(reviewApi);
+			requireSkillPermission(scope, "skill:manage");
+			if (!isAdmin(scope) && !isDeptAdmin(scope)) {
+				const found = (await listSkills(scope, false)).skills.find((row) => row.id === args.skill_id);
+				if (found === void 0 || found.sharedByMe !== true) throw forbidden("only the owner or an administrator may unshare this skill");
+			}
+			await approve("skill_unshare", exec, "Unshare skill " + args.skill_id.toString());
+			await call("/api/ai/skill-plaza/skills/" + args.skill_id.toString(), { method: "DELETE" });
+			audit("skill_unshare", exec, {
+				skillId: args.skill_id,
+				effect: "soft-unpublish"
+			});
+			return {
+				unshared: args.skill_id,
+				effect: "plaza-sharing-disabled"
+			};
+		}
+	}));
+	register(defineTool({
+		name: "skill_delete",
+		description: "Permanently delete one plaza skill. This is not unshare: the record is removed, DataOps sends a “deleted” notification (not “unpublished”), and the audit entry records the permanent action. Requires confirm=true as a second confirmation; owners may delete their own entries, 超级管理员/管理员 any entry, 部门管理员 their department. If installations still exist the backend returns 409 and the error is passed through. Requires user approval; audited.",
+		parameters: {
+			skill_id: {
+				type: "number",
+				required: true,
+				description: "Plaza skill id."
+			},
+			confirm: {
+				type: "boolean",
+				required: true,
+				description: "Must be true: explicitly confirms permanent deletion."
+			}
+		},
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args, exec) => {
+			if (args.confirm !== true) throw new Error("skill_delete requires confirm=true (permanent deletion)");
+			const scope = await loadScope(reviewApi);
+			requireSkillPermission(scope, "skill:manage");
+			if (!isAdmin(scope) && !isDeptAdmin(scope)) {
+				const found = (await listSkills(scope, false)).skills.find((row) => row.id === args.skill_id);
+				if (found === void 0 || found.sharedByMe !== true) throw forbidden("only the owner or an administrator may delete this skill");
+			}
+			await approve("skill_delete", exec, "Permanently delete skill " + args.skill_id.toString());
+			await call("/api/ai/skill-plaza/skills/" + args.skill_id.toString() + "/permanent", { method: "DELETE" });
+			audit("skill_delete", exec, {
+				skillId: args.skill_id,
+				permanent: true
+			});
+			return {
+				deleted: args.skill_id,
+				permanent: true
+			};
+		}
+	}));
+	register(defineTool({
+		name: "review_scan",
+		description: "Run the DataOps AI risk scan for skill and/or workflow ids. Reviewers only (超级管理员/管理员/部门管理员 with review capability); ordinary users receive 403. Read-only.",
+		parameters: {
+			skills: {
+				type: "array",
+				items: { type: "number" },
+				description: "Skill ids to scan."
+			},
+			workflows: {
+				type: "array",
+				items: { type: "string" },
+				description: "Workflow ids to scan."
+			}
+		},
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args) => {
+			const scope = await loadScope(reviewApi);
+			requireSkillPermission(scope, "skill:read");
+			if (!canReview(scope)) throw forbidden("the current role cannot review");
+			return await call("/api/ai/review/scan", {
+				method: "POST",
+				body: JSON.stringify({
+					skills: args.skills ?? [],
+					workflows: args.workflows ?? []
+				})
+			});
+		}
+	}));
+	register(defineTool({
+		name: "review_decide",
+		description: "Approve or reject skills/workflows. Requires authorization.confirmed=true (the administrator explicitly confirmed), reviewer role and department scope; requires a second user approval at tool level and writes an audit entry. Ordinary users receive 403.",
+		parameters: {
+			skills: {
+				type: "array",
+				items: { type: "number" },
+				description: "Skill ids."
+			},
+			workflows: {
+				type: "array",
+				items: { type: "string" },
+				description: "Workflow ids."
+			},
+			decision: {
+				type: "string",
+				required: true,
+				description: "approve or reject."
+			},
+			note: {
+				type: "string",
+				description: "Review note (max 2000 chars)."
+			},
+			confirmed: {
+				type: "boolean",
+				required: true,
+				description: "Must be true: the administrator confirmed this decision."
+			}
+		},
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args, exec) => {
+			const scope = await loadScope(reviewApi);
+			requireSkillPermission(scope, "skill:review:decide");
+			if (!canReview(scope)) throw forbidden("the current role cannot review");
+			if (args.confirmed !== true) throw new Error("authorization.confirmed=true is required for review_decide");
+			if (args.decision !== "approve" && args.decision !== "reject") throw new Error("decision must be approve or reject");
+			if ((args.skills ?? []).length === 0 && (args.workflows ?? []).length === 0) throw new Error("at least one skill or workflow id is required");
+			if (!isAdmin(scope) && isDeptAdmin(scope)) {
+				const rows = (await listSkills(scope, false)).skills;
+				const allowed = new Set(scope.dataScope?.departmentCodes ?? (scope.departmentCode === void 0 ? [] : [scope.departmentCode]));
+				for (const id of args.skills ?? []) {
+					const row = rows.find((item) => item.id === id);
+					if (row !== void 0 && (row.departmentCode === null || row.departmentCode === void 0)) requireSkillPermission(scope, "skill:review:global");
+					if (row !== void 0 && row.departmentCode !== null && row.departmentCode !== void 0 && !allowed.has(String(row.departmentCode))) throw forbidden("department administrators may only review their own department");
+				}
+			}
+			await approve("review_decide", exec, "Review " + args.decision + " for " + (args.skills ?? []).length.toString() + " skill(s) / " + (args.workflows ?? []).length.toString() + " workflow(s)");
+			const value = await call("/api/ai/review/decide", {
+				method: "POST",
+				body: JSON.stringify({
+					skills: args.skills ?? [],
+					workflows: args.workflows ?? [],
+					decision: args.decision,
+					note: args.note ?? "",
+					authorization: { confirmed: true }
+				})
+			});
+			audit("review_decide", exec, {
+				decision: args.decision,
+				skills: args.skills ?? [],
+				workflows: args.workflows ?? [],
+				confirmed: true
+			});
+			return value;
+		}
+	}));
+	register(defineTool({
+		name: "review_notifications_list",
+		description: "List the caller's review notifications and unread count. Read-only and always scoped to the current DataOps user.",
+		parameters: {
+			unread_only: {
+				type: "boolean",
+				description: "Only unread notifications."
+			},
+			limit: {
+				type: "number",
+				description: "Maximum rows (default 20)."
+			}
+		},
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args) => {
+			await loadScope(reviewApi);
+			const query = new URLSearchParams({
+				unreadOnly: args.unread_only === true ? "true" : "false",
+				limit: String(args.limit ?? 20)
+			});
+			return await call("/api/ai/review-notifications?" + query.toString());
+		}
+	}));
+	register(defineTool({
+		name: "review_notifications_read",
+		description: "Mark the caller's review notifications as read, either selected ids or all. Scoped to the current DataOps user; no secret is involved.",
+		parameters: {
+			ids: {
+				type: "array",
+				items: { type: "string" },
+				description: "Notification ids to mark read."
+			},
+			all: {
+				type: "boolean",
+				description: "Mark every notification read."
+			}
+		},
+		output: {
+			schema: open,
+			render
+		},
+		execute: async (args, exec) => {
+			await loadScope(reviewApi);
+			const value = await call("/api/ai/review-notifications/read", {
+				method: "POST",
+				body: JSON.stringify({
+					ids: args.ids ?? [],
+					all: args.all === true
+				})
+			});
+			audit("review_notifications_read", exec, {
+				count: args.ids?.length ?? 0,
+				all: args.all === true
+			});
+			return value;
+		}
+	}));
+	return () => {
+		for (const dispose of disposers) dispose();
+	};
+}
+//#endregion
 //#region src/workspace-limits.ts
 /** Narrow a value to a plain object. */
 function asRecord(value) {
@@ -749,7 +1375,11 @@ var WorkspaceLimits = class {
 		const token = await this.token();
 		if (token === void 0) return void 0;
 		const response = await fetch(new URL("/api/ai/attachment-settings", this.apiBase()), { headers: { authorization: `Bearer ${token}` } });
-		if (response.status === 401) return void 0;
+		if (response.status === 401) {
+			noteExpired();
+			return;
+		}
+		noteAccepted();
 		if (!response.ok) throw new WorkspaceLimitsRejection(response.status, await rejectionMessage(response, "Workspace limits read failed"));
 		const body = asRecord(await response.json());
 		const settings = body === null ? null : asRecord(body.settings);
@@ -782,7 +1412,11 @@ var WorkspaceLimits = class {
 			},
 			body: JSON.stringify({ workspaceSize: limits })
 		});
-		if (response.status === 401) return void 0;
+		if (response.status === 401) {
+			noteExpired();
+			return;
+		}
+		noteAccepted();
 		if (!response.ok) throw new WorkspaceLimitsRejection(response.status, await rejectionMessage(response, "Workspace limits write failed"));
 		return this.status();
 	}
@@ -797,6 +1431,302 @@ function setWorkspaceLimits(next) {
 function currentWorkspaceLimits() {
 	return limitsRef;
 }
+/** Directory used by this plugin below the DSH home. */
+const WORKSPACE_UPGRADE_STATE_DIR = "dataops-managed";
+/** Name of the hand-off file. */
+const WORKSPACE_UPGRADE_STATE_FILE = "workspace-upgrade.json";
+/**
+* Resolve the persistent DSH home used by this workspace.
+*
+* The companion currently starts with `DSH_HOME=/workspace/.dataops/dsh`; the fallback
+* keeps tests and a manually launched host deterministic without reaching outside the
+* mounted workspace.
+* @param dshHome - override for tests.
+* @returns the state directory path.
+*/
+function workspaceUpgradeStatePath(dshHome = process.env.DSH_HOME ?? "/workspace/.dataops/dsh") {
+	return join(dshHome, WORKSPACE_UPGRADE_STATE_DIR, WORKSPACE_UPGRADE_STATE_FILE);
+}
+/** Validate one persisted session entry. */
+function asSession(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	const record = value;
+	if (typeof record.sessionId !== "string" || record.sessionId.trim() === "") return null;
+	return {
+		sessionId: record.sessionId.trim(),
+		...typeof record.title === "string" && record.title.trim() !== "" ? { title: record.title.trim() } : {},
+		...typeof record.cwd === "string" && record.cwd.trim() !== "" ? { cwd: record.cwd.trim() } : {}
+	};
+}
+/** Validate a parsed state document. */
+function asWorkspaceUpgradeState(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	const record = value;
+	if (record.version !== 1) return null;
+	if (typeof record.upgradeId !== "string" || record.upgradeId.trim() === "") return null;
+	if (typeof record.targetImage !== "string" || record.targetImage.trim() === "") return null;
+	if (!Array.isArray(record.sessions)) return null;
+	const sessions = record.sessions.map(asSession).filter((session) => session !== null);
+	return {
+		version: 1,
+		upgradeId: record.upgradeId.trim(),
+		targetImage: record.targetImage.trim(),
+		sessions,
+		createdAt: typeof record.createdAt === "string" ? record.createdAt : (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+/**
+* Read the pending hand-off record.
+* @param file - state file path.
+* @returns the record, or null when none exists or it cannot be parsed.
+*/
+async function readWorkspaceUpgradeState(file = workspaceUpgradeStatePath()) {
+	try {
+		return asWorkspaceUpgradeState(JSON.parse(await readFile(file, "utf8")));
+	} catch {
+		return null;
+	}
+}
+/**
+* Persist the hand-off record atomically.
+*
+* A partially written JSON file would be indistinguishable from "no upgrade pending",
+* which would silently skip recovery. The temporary file is renamed into place only
+* after the content is complete.
+* @param state - record to persist.
+* @param file - state file path.
+*/
+async function writeWorkspaceUpgradeState(state, file = workspaceUpgradeStatePath()) {
+	await mkdir(dirname(file), { recursive: true });
+	const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+	await writeFile(temporary, JSON.stringify(state, null, 2) + "\n", "utf8");
+	await rename(temporary, file);
+}
+/**
+* Remove the hand-off record after recovery has been attempted.
+* @param file - state file path.
+*/
+async function clearWorkspaceUpgradeState(file = workspaceUpgradeStatePath()) {
+	await rm(file, { force: true });
+}
+//#endregion
+//#region src/workspace-upgrade.ts
+/**
+* Workspace image upgrade orchestration.
+*
+* DataOps owns the Docker image comparison and the container restart. This plugin owns
+* the two facts DSH alone can know: which sessions are running right now, and how to
+* bring those sessions back after the container has been recreated. A small JSON file
+* on the shared workspace volume carries that hand-off across the restart.
+*
+* @module workspace-upgrade
+*/
+/** A refusal or transport failure from the DataOps API. */
+var WorkspaceUpgradeError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "WorkspaceUpgradeError";
+	}
+};
+/** Create the user-message value `agent.followup` accepts. */
+function userMessage(text) {
+	return {
+		id: randomUUID(),
+		role: "user",
+		content: [{
+			type: "text",
+			text
+		}],
+		source: { kind: "user" }
+	};
+}
+/** Extract a useful message from a DataOps error body. */
+async function responseMessage(response, fallback) {
+	try {
+		const message = (await response.json()).message;
+		if (typeof message === "string" && message.trim() !== "") return message;
+		if (Array.isArray(message) && typeof message[0] === "string") return message[0];
+	} catch {}
+	return `${fallback} (HTTP ${String(response.status)})`;
+}
+/** Owns DataOps preview/restart calls and the DSH session hand-off. */
+var WorkspaceUpgrade = class {
+	ctx;
+	config;
+	statePath;
+	constructor(ctx, config, statePath = workspaceUpgradeStatePath()) {
+		this.ctx = ctx;
+		this.config = config;
+		this.statePath = statePath;
+	}
+	/** Resolve the injected DSH agents service, if the profile provides one. */
+	agents() {
+		return this.ctx.agents;
+	}
+	/** Read the current DataOps credential. */
+	async token() {
+		return (await this.ctx.credentials.resolve(credentialRef(this.config.credentialRef)))?.value;
+	}
+	/** DataOps origin used by this workspace. */
+	apiBase() {
+		return new URL(this.config.baseUrl).origin;
+	}
+	/** Call one DataOps API path with the workspace JWT. */
+	async request(path, init) {
+		const token = await this.token();
+		if (token === void 0) throw new WorkspaceUpgradeError(401, "workspace is not signed in to DataOps");
+		let response;
+		try {
+			response = await fetch(new URL(path, this.apiBase()), {
+				...init,
+				headers: {
+					authorization: `Bearer ${token}`,
+					...init?.body === void 0 ? {} : { "content-type": "application/json" },
+					...init?.headers ?? {}
+				}
+			});
+		} catch (error) {
+			throw new WorkspaceUpgradeError(502, error instanceof Error ? error.message : String(error));
+		}
+		if (response.status === 401) {
+			noteExpired();
+			throw new WorkspaceUpgradeError(401, "DataOps session has ended");
+		}
+		noteAccepted();
+		return response;
+	}
+	/** Read the DataOps restart preview plus this host's running-session snapshot. */
+	async preview() {
+		const response = await this.request("/api/ai/workspace/restart-preview");
+		if (!response.ok) throw new WorkspaceUpgradeError(response.status, await responseMessage(response, "workspace preview failed"));
+		const body = await response.json();
+		const imageStatus = body.workspace?.imageStatus;
+		if (imageStatus !== "CURRENT" && imageStatus !== "UPDATE_AVAILABLE" && imageStatus !== "NOT_RUNNING" && imageStatus !== "UNKNOWN") throw new WorkspaceUpgradeError(502, "workspace preview returned an unrecognized image status");
+		return {
+			imageStatus,
+			configuredImage: typeof body.workspace?.configuredImage === "string" ? body.workspace.configuredImage : "",
+			activeSessions: this.runningSessions()
+		};
+	}
+	/** Snapshot sessions that are executing a turn right now. */
+	runningSessions() {
+		const agents = this.agents();
+		if (agents === void 0) return [];
+		return agents.list().filter((agent) => agent.status === "running").map((agent) => ({
+			sessionId: agent.session.id,
+			...agent.session.header?.title ? { title: agent.session.header.title } : {},
+			...agent.session.header?.cwd ? { cwd: agent.session.header.cwd } : {}
+		}));
+	}
+	/** Restart DataOps' workspace container; force is required when sessions are snapshot. */
+	async restart() {
+		const response = await this.request("/api/ai/workspace/restart", {
+			method: "POST",
+			body: JSON.stringify({ force: true })
+		});
+		if (!response.ok) throw new WorkspaceUpgradeError(response.status, await responseMessage(response, "workspace restart failed"));
+	}
+	/**
+	* Persist the running-session snapshot and ask DataOps to recreate the container.
+	* @returns the accepted hand-off record.
+	*/
+	async upgrade() {
+		const preview = await this.preview();
+		if (preview.imageStatus !== "UPDATE_AVAILABLE") throw new WorkspaceUpgradeError(409, "workspace image is already current or not running");
+		const state = {
+			version: 1,
+			upgradeId: randomUUID(),
+			targetImage: preview.configuredImage,
+			sessions: preview.activeSessions,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await writeWorkspaceUpgradeState(state, this.statePath);
+		try {
+			await this.restart();
+		} catch (error) {
+			await clearWorkspaceUpgradeState(this.statePath);
+			throw error;
+		}
+		return state;
+	}
+	/**
+	* Resume every snapshotted session and send one "继续".
+	*
+	* The method deliberately does not wait for an answer: the user's workspace should
+	* become usable immediately, and an in-flight tool call cannot be replayed safely.
+	* `recoverWorkspaceUpgradeAfterBoot` removes the hand-off file after this attempt.
+	*/
+	async recover() {
+		const state = await readWorkspaceUpgradeState(this.statePath);
+		if (state === null) return {
+			recovered: 0,
+			skipped: 0
+		};
+		if (this.agents() === void 0) throw new Error("DSH agents service is not ready");
+		let recovered = 0;
+		let skipped = 0;
+		for (const session of state.sessions) try {
+			const agent = await this.ensureAgent(session.sessionId);
+			if (agent === void 0) {
+				skipped += 1;
+				continue;
+			}
+			agent.followup(userMessage("继续"));
+			recovered += 1;
+		} catch (error) {
+			skipped += 1;
+			this.ctx.logger.warn(`dataops-managed: could not resume session ${session.sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		return {
+			recovered,
+			skipped
+		};
+	}
+	/** Remove the hand-off record once recovery has been attempted. */
+	async clearRecoveryState() {
+		await clearWorkspaceUpgradeState(this.statePath);
+	}
+	/** Find a live session or resume it from persisted state. */
+	async ensureAgent(sessionId) {
+		const agents = this.agents();
+		if (agents === void 0) return void 0;
+		const live = agents.get(sessionId);
+		if (live !== void 0) return live;
+		return (await agents.resume({ resumeSessionId: sessionId }))?.agent;
+	}
+};
+/** Delay helper for boot-time recovery without keeping the plugin apply() pending. */
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+/**
+* Run recovery after the DSH host and its session persistence have had time to boot.
+*
+* `apply()` runs before a persisted session necessarily has its live agent; resuming
+* eagerly can race that boot. A short bounded retry is enough, and a failed attempt
+* still removes the hand-off file so the next page load cannot send "继续" forever.
+* @param upgrade - upgrade service.
+*/
+async function recoverWorkspaceUpgradeAfterBoot(upgrade) {
+	let lastState = null;
+	for (let attempt = 0; attempt < 10; attempt += 1) {
+		const state = await readWorkspaceUpgradeState(upgrade.statePath);
+		if (state === null) return;
+		lastState = state;
+		if (attempt > 0) await sleep(1500);
+		try {
+			if ((await upgrade.recover()).recovered > 0 || state.sessions.length === 0) {
+				await upgrade.clearRecoveryState();
+				return;
+			}
+		} catch (error) {
+			console.warn("[dataops-managed] workspace upgrade recovery failed:", error);
+		}
+	}
+	if (lastState !== null) await upgrade.clearRecoveryState();
+}
 //#endregion
 //#region src/index.ts
 /** Cordis plugin name for the DataOps-managed integration. */
@@ -807,7 +1737,9 @@ const inject = [
 	"webServer",
 	"tools",
 	"settings",
-	"skills"
+	"skills",
+	"approval",
+	"agents"
 ];
 const MANAGED_AUTH_PATH = "/integrations/dataops/managed-auth";
 /** This plugin's profile entry id, which owns its Config and sync state. */
@@ -816,10 +1748,26 @@ const MANAGED_PLUGIN_ID = "dataops-managed";
 const MODEL_SYNC_PATH = "/integrations/dataops/model-sync";
 /** Same-origin route the skill center uses to read and change plaza sharing. */
 const SKILL_PLAZA_PATH = "/integrations/dataops/skill-plaza";
+/** Caller role and review capability. */
+const REVIEW_CONTEXT_PATH = "/integrations/dataops/review-context";
+/** Notification inbox and read receipts. */
+const REVIEW_NOTIFICATIONS_PATH = "/integrations/dataops/review-notifications";
+/** AI scan and the administrator's decision. */
+const REVIEW_ACTION_PATH = "/integrations/dataops/review";
+/** Permission-centre reads and writes. */
+const RBAC_PATH = "/integrations/dataops/rbac";
+/** The three plaza-review switches. */
+const REVIEW_SETTINGS_PATH = "/integrations/dataops/review-settings";
+/** Department CRUD bridge (task-67). */
+const DEPARTMENTS_PATH = "/integrations/dataops/departments";
 /** Same-origin route the Settings panel uses to read and change this workspace's limits. */
 const WORKSPACE_LIMITS_PATH = "/integrations/dataops/workspace-limits";
 /** Same-origin route the Settings panel uses to read and change the tool-call timeout. */
 const TOOL_TIMEOUT_PATH = "/integrations/dataops/tool-timeout";
+/** Same-origin route reporting what the last DataOps answer said about the credential. */
+const AUTH_STATE_PATH = "/integrations/dataops/auth-state";
+/** Same-origin route the DSH page uses to detect and start a workspace image upgrade. */
+const WORKSPACE_UPGRADE_PATH = "/integrations/dataops/workspace-upgrade";
 /** The ends a tool-call timeout may take, in whole seconds. */
 const TOOL_TIMEOUT_MIN_SECONDS = 1;
 const TOOL_TIMEOUT_MAX_SECONDS = 3600;
@@ -827,6 +1775,8 @@ const TOOL_TIMEOUT_MAX_SECONDS = 3600;
 let modelSyncRef;
 /** The live plaza instance, so the skill center routes can act on it after activation. */
 let skillPlazaRef;
+/** The live review API, once this plugin activated. */
+let reviewApiRef;
 /** The live skill plaza, once this plugin activated. */
 function currentSkillPlaza() {
 	return skillPlazaRef;
@@ -903,6 +1853,34 @@ function bearerToken(request) {
 	const token = authorization.slice(7).trim();
 	return token === "" ? null : token;
 }
+/**
+* Adopt the JWT the browser gateway attached to one request.
+*
+* Every browser request reaches this workspace through the DataOps gateway, which resolves the
+* caller's session and forwards a fresh `authorization: Bearer <jwt>` — so the current credential
+* arrives continuously, without any push, handshake or refresh protocol. The routes below are
+* the only place this plugin can see that header, and reading it here is what keeps the stored
+* credential from going stale: the value in it was captured once, while the caller's session is
+* renewed by DataOps for as long as they stay signed in.
+*
+* A request without the header is normal rather than an error (same-origin fetches from inside
+* the workspace do carry it, but a probe or a health check may not), so this only ever improves
+* the stored value and never rejects the request.
+*
+* @param request - the incoming request, whose headers the gateway filled in.
+* @returns once the credential has been updated, or immediately when there is nothing to adopt.
+*/
+function adoptRequestJwt(ctx, accessRef, request) {
+	const token = bearerToken(request);
+	if (token === null) return Promise.resolve();
+	return (async () => {
+		if ((await ctx.credentials.resolve(accessRef))?.value === token) return;
+		await ctx.credentials.set(accessRef, token);
+	})().catch((error) => {
+		ctx.logger.warn("dataops-managed: request JWT could not be adopted");
+		ctx.logger.warn(error);
+	});
+}
 /** The skill this plugin contributes: how to answer a DataOps data question. */
 const QUERY_SKILL_NAME = "dataops-query";
 /** Location of the skill document inside the published package. */
@@ -1061,10 +2039,20 @@ async function apply(ctx, config) {
 		baseUrl,
 		credentialRef: config.credentialRef
 	});
+	const reviewApi = new ReviewApi(ctx, {
+		baseUrl,
+		credentialRef: config.credentialRef
+	});
+	reviewApiRef = reviewApi;
+	ctx.effect(() => registerAiManagementTools(ctx, reviewApi), "dataops-managed: skill and review tools");
 	setWorkspaceLimits(new WorkspaceLimits(ctx, {
 		baseUrl,
 		credentialRef: config.credentialRef
 	}));
+	const workspaceUpgrade = new WorkspaceUpgrade(ctx, {
+		baseUrl,
+		credentialRef: config.credentialRef
+	});
 	/**
 	* Adopt the publisher's models once the workspace has a session.
 	*
@@ -1086,7 +2074,7 @@ async function apply(ctx, config) {
 			ctx.logger.warn(error);
 		}
 	};
-	if (await ctx.credentials.resolve(accessRef) !== void 0) await adoptNow();
+	if (await ctx.credentials.resolve(accessRef) !== void 0) adoptNow();
 	ctx.effect(() => ctx.webServer.register({
 		kind: "exact",
 		path: MANAGED_AUTH_PATH,
@@ -1099,6 +2087,7 @@ async function apply(ctx, config) {
 				response.end();
 				return;
 			}
+			await adoptRequestJwt(ctx, accessRef, request);
 			const token = bearerToken(request);
 			if (token === null) {
 				response.writeHead(401, { "content-length": "0" });
@@ -1217,12 +2206,18 @@ async function apply(ctx, config) {
 			try {
 				if (request.method === "GET") {
 					const url = new URL(request.url ?? "/", "http://localhost");
+					const mine = url.searchParams.get("mine") === "1";
+					const page = await plaza.listPage({
+						tag: url.searchParams.get("tag") ?? void 0,
+						query: url.searchParams.get("q") ?? void 0,
+						status: url.searchParams.get("status") ?? void 0,
+						scope: mine ? "mine" : url.searchParams.get("scope") ?? void 0,
+						departmentCode: url.searchParams.get("departmentCode") ?? void 0
+					});
 					writeJson(response, 200, {
-						skills: await plaza.list({
-							tag: url.searchParams.get("tag") ?? void 0,
-							query: url.searchParams.get("q") ?? void 0
-						}),
-						tags: await plaza.tags()
+						skills: mine ? page.skills.filter((skill) => skill.sharedByMe) : page.skills,
+						tags: mine ? [] : await plaza.tags(),
+						...page.counts === void 0 ? {} : { counts: page.counts }
 					});
 					return;
 				}
@@ -1240,17 +2235,52 @@ async function apply(ctx, config) {
 					writeJson(response, 200, { skills: await readLocalSkills(ctx) });
 					return;
 				}
-				if (action === "share") {
+				if (action === "share" || action === "submit") {
 					const name = typeof body?.name === "string" ? body.name : "";
 					const instruction = typeof body?.instruction === "string" ? body.instruction : "";
 					const description = typeof body?.description === "string" ? body.description : void 0;
 					const tags = Array.isArray(body?.tags) ? body.tags.filter((tag) => typeof tag === "string") : [];
-					writeJson(response, 200, { skill: await plaza.share({
-						name,
-						description,
-						instruction,
-						tags
-					}) });
+					if (name.trim() === "" || instruction.trim() === "") {
+						writeJson(response, 400, { error: "name and instruction are required" });
+						return;
+					}
+					writeJson(response, 200, {
+						ok: true,
+						skill: await plaza.share({
+							name,
+							description,
+							instruction,
+							tags
+						})
+					});
+					return;
+				}
+				if (action === "review") {
+					const api = reviewApiRef;
+					if (api === void 0) {
+						writeJson(response, 503, { error: "review api is not active" });
+						return;
+					}
+					const id = typeof body?.id === "number" ? body.id : void 0;
+					const decision = body?.decision === "reject" ? "reject" : body?.decision === "approve" ? "approve" : null;
+					if (id === void 0 || decision === null) {
+						writeJson(response, 400, { error: "id and decision are required" });
+						return;
+					}
+					const result = await api.request("/api/ai/review/decide", {
+						method: "POST",
+						body: JSON.stringify({
+							skills: [id],
+							workflows: [],
+							decision,
+							note: typeof body?.note === "string" ? body.note : "",
+							authorization: {
+								confirmed: true,
+								reason: "skill-plaza-review"
+							}
+						})
+					});
+					writeJson(response, result.status, result.body);
 					return;
 				}
 				if (action === "unshare") {
@@ -1275,6 +2305,306 @@ async function apply(ctx, config) {
 		}
 	}), "dataops-managed: skill plaza routes");
 	/**
+	* Review context, notifications, AI scan/decide, the permission centre and review settings.
+	*
+	* These are thin same-origin bridges: DataOps owns identity, authorization, the state machine
+	* and the audit trail; this route only attaches the workspace JWT and forwards answers so the
+	* browser can show a precise waiting/refused state instead of flattening both to "empty".
+	*/
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: REVIEW_CONTEXT_PATH,
+		handler: async (request, response) => {
+			if (request.method !== "GET") {
+				response.writeHead(405, {
+					allow: "GET",
+					"content-length": "0"
+				});
+				response.end();
+				return;
+			}
+			const api = reviewApiRef;
+			if (api === void 0) {
+				writeJson(response, 503, { error: "review api is not active" });
+				return;
+			}
+			try {
+				const result = await api.request("/api/ai/review/context");
+				writeJson(response, result.status, result.body);
+			} catch (error) {
+				ctx.logger.warn("dataops-managed: review context failed");
+				writeJson(response, 502, { error: error instanceof Error ? error.message : String(error) });
+			}
+		}
+	}), "dataops-managed: review context route");
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: REVIEW_NOTIFICATIONS_PATH,
+		handler: async (request, response) => {
+			const api = reviewApiRef;
+			if (api === void 0) {
+				writeJson(response, 503, { error: "review api is not active" });
+				return;
+			}
+			try {
+				if (request.method === "GET") {
+					const url = new URL(request.url ?? "/", "http://localhost");
+					const params = new URLSearchParams();
+					if (url.searchParams.get("unreadOnly") === "true") params.set("unreadOnly", "true");
+					if (url.searchParams.get("limit") !== null) params.set("limit", url.searchParams.get("limit"));
+					const result = await api.request("/api/ai/review-notifications" + (params.size === 0 ? "" : "?" + params.toString()));
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				if (request.method !== "POST") {
+					response.writeHead(405, {
+						allow: "GET, POST",
+						"content-length": "0"
+					});
+					response.end();
+					return;
+				}
+				const body = await readJson(request);
+				const result = await api.request("/api/ai/review-notifications/read", {
+					method: "POST",
+					body: JSON.stringify(body ?? {})
+				});
+				writeJson(response, result.status, result.body);
+			} catch (error) {
+				ctx.logger.warn("dataops-managed: review notifications failed");
+				writeJson(response, 502, { error: error instanceof Error ? error.message : String(error) });
+			}
+		}
+	}), "dataops-managed: review notifications route");
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: REVIEW_ACTION_PATH,
+		handler: async (request, response) => {
+			if (request.method !== "POST") {
+				response.writeHead(405, {
+					allow: "POST",
+					"content-length": "0"
+				});
+				response.end();
+				return;
+			}
+			const api = reviewApiRef;
+			if (api === void 0) {
+				writeJson(response, 503, { error: "review api is not active" });
+				return;
+			}
+			try {
+				const body = await readJson(request);
+				const action = typeof body?.action === "string" ? body.action : "";
+				const skills = Array.isArray(body?.skills) ? body.skills : [];
+				const workflows = Array.isArray(body?.workflows) ? body.workflows : [];
+				if (action === "scan") {
+					const result = await api.request("/api/ai/review/scan", {
+						method: "POST",
+						body: JSON.stringify({
+							skills,
+							workflows
+						})
+					});
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				if (action === "decide") {
+					const result = await api.request("/api/ai/review/decide", {
+						method: "POST",
+						body: JSON.stringify({
+							skills,
+							workflows,
+							decision: body?.decision,
+							note: body?.note,
+							authorization: body?.authorization
+						})
+					});
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				writeJson(response, 400, { error: "unknown review action" });
+			} catch (error) {
+				ctx.logger.warn("dataops-managed: review action failed");
+				writeJson(response, 502, { error: error instanceof Error ? error.message : String(error) });
+			}
+		}
+	}), "dataops-managed: review action route");
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: RBAC_PATH,
+		handler: async (request, response) => {
+			const api = reviewApiRef;
+			if (api === void 0) {
+				writeJson(response, 503, { error: "review api is not active" });
+				return;
+			}
+			try {
+				if (request.method === "GET") {
+					const url = new URL(request.url ?? "/", "http://localhost");
+					const section = url.searchParams.get("section") ?? "matrix";
+					const suffix = section === "members" ? "?q=" + encodeURIComponent(url.searchParams.get("q") ?? "") + "&departmentCode=" + encodeURIComponent(url.searchParams.get("departmentCode") ?? "") : section === "resources" ? "?kind=" + encodeURIComponent(url.searchParams.get("kind") ?? "") : "";
+					const target = section === "members" ? "/api/system/permission-center/members" + suffix : section === "departments" ? "/api/system/permission-center/departments" : section === "resources" ? "/api/system/permission-center/resources" + suffix : "/api/system/permission-center/matrix" + (url.searchParams.get("scope") === "dsh" ? "?scope=dsh" : "");
+					const result = await api.request(target);
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				if (request.method !== "PUT") {
+					response.writeHead(405, {
+						allow: "GET, PUT",
+						"content-length": "0"
+					});
+					response.end();
+					return;
+				}
+				const body = await readJson(request);
+				const section = typeof body?.section === "string" ? body.section : "";
+				const value = typeof body?.value === "object" && body.value !== null ? body.value : {};
+				if (section === "roles") {
+					const result = await api.request("/api/system/permission-center/matrix", {
+						method: "PUT",
+						body: JSON.stringify(value)
+					});
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				if (section === "members" && typeof value.userId === "string") {
+					const result = await api.request("/api/system/permission-center/members/" + encodeURIComponent(value.userId) + "/roles", {
+						method: "PUT",
+						body: JSON.stringify({ roleCodes: value.roleCodes })
+					});
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				if (section === "departments" && typeof value.code === "string") {
+					const result = await api.request("/api/system/permission-center/departments/" + encodeURIComponent(value.code) + "/admin", {
+						method: "PUT",
+						body: JSON.stringify({ userIds: value.userIds })
+					});
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				if (section === "resources" && typeof value.kind === "string" && value.id !== void 0) {
+					const result = await api.request("/api/system/permission-center/resources/" + encodeURIComponent(value.kind) + "/" + encodeURIComponent(String(value.id)) + "/scope", {
+						method: "PUT",
+						body: JSON.stringify({
+							departmentCode: value.departmentCode,
+							visibility: value.visibility,
+							ownerId: value.ownerId
+						})
+					});
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				writeJson(response, 400, { error: "unknown rbac section" });
+			} catch (error) {
+				ctx.logger.warn("dataops-managed: permission centre failed");
+				writeJson(response, 502, { error: error instanceof Error ? error.message : String(error) });
+			}
+		}
+	}), "dataops-managed: permission centre route");
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: DEPARTMENTS_PATH,
+		handler: async (request, response) => {
+			const api = reviewApiRef;
+			if (api === void 0) {
+				writeJson(response, 503, { error: "review api is not active" });
+				return;
+			}
+			try {
+				const body = await readJson(request);
+				if (request.method === "POST") {
+					const result = await api.request("/api/system/departments", {
+						method: "POST",
+						body: JSON.stringify(body ?? {})
+					});
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				if (request.method !== "PATCH" && request.method !== "DELETE") {
+					response.writeHead(405, {
+						allow: "POST, PATCH, DELETE",
+						"content-length": "0"
+					});
+					response.end();
+					return;
+				}
+				const code = typeof body?.code === "string" ? body.code : "";
+				if (code === "") {
+					writeJson(response, 400, { error: "department code is required" });
+					return;
+				}
+				const current = await api.request("/api/system/departments/" + encodeURIComponent(code));
+				const record = typeof current.body === "object" && current.body !== null ? current.body : {};
+				const department = typeof record.department === "object" && record.department !== null ? record.department : {};
+				const updatedAt = typeof body?.updatedAt === "string" ? body.updatedAt : department.updatedAt;
+				if (typeof updatedAt !== "string") {
+					writeJson(response, current.status === 200 ? 409 : current.status, { error: "department not found" });
+					return;
+				}
+				if (request.method === "PATCH") {
+					const result = await api.request("/api/system/departments/" + encodeURIComponent(code), {
+						method: "PATCH",
+						body: JSON.stringify({
+							updatedAt,
+							name: body?.name,
+							parentCode: body?.parentCode,
+							description: body?.description,
+							owner: body?.owner,
+							enabled: body?.enabled
+						})
+					});
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				const result = await api.request("/api/system/departments/" + encodeURIComponent(code), {
+					method: "DELETE",
+					body: JSON.stringify({ updatedAt })
+				});
+				writeJson(response, result.status, result.body);
+			} catch (error) {
+				ctx.logger.warn("dataops-managed: department bridge failed");
+				writeJson(response, 502, { error: error instanceof Error ? error.message : String(error) });
+			}
+		}
+	}), "dataops-managed: department CRUD bridge");
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: REVIEW_SETTINGS_PATH,
+		handler: async (request, response) => {
+			const api = reviewApiRef;
+			if (api === void 0) {
+				writeJson(response, 503, { error: "review api is not active" });
+				return;
+			}
+			try {
+				if (request.method === "GET") {
+					const result = await api.request("/api/integrations/dataops/review-settings");
+					writeJson(response, result.status, result.body);
+					return;
+				}
+				if (request.method !== "PUT" && request.method !== "POST") {
+					response.writeHead(405, {
+						allow: "GET, POST, PUT",
+						"content-length": "0"
+					});
+					response.end();
+					return;
+				}
+				const body = await readJson(request);
+				const result = await api.request("/api/integrations/dataops/review-settings", {
+					method: "POST",
+					body: JSON.stringify(body ?? {})
+				});
+				writeJson(response, result.status, result.body);
+			} catch (error) {
+				ctx.logger.warn("dataops-managed: review settings failed");
+				writeJson(response, 502, { error: error instanceof Error ? error.message : String(error) });
+			}
+		}
+	}), "dataops-managed: review settings route");
+	/**
 	* The workspace limits an administrator sets in DataOps.
 	*
 	* Read through the plugin because it holds the DataOps JWT; the page cannot reach those settings
@@ -1378,6 +2708,67 @@ async function apply(ctx, config) {
 			}
 		}
 	}), "dataops-managed: tool timeout route");
+	/**
+	* Workspace image upgrade: DataOps owns the image comparison and restart; this
+	* plugin adds the DSH-side running-session snapshot and post-restart recovery.
+	*/
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: WORKSPACE_UPGRADE_PATH,
+		handler: async (request, response) => {
+			try {
+				if (request.method === "GET") {
+					const preview = await workspaceUpgrade.preview();
+					writeJson(response, 200, {
+						imageStatus: preview.imageStatus,
+						configuredImage: preview.configuredImage,
+						activeSessions: preview.activeSessions
+					});
+					return;
+				}
+				if (request.method !== "POST") {
+					response.writeHead(405, {
+						allow: "GET, POST",
+						"content-length": "0"
+					});
+					response.end();
+					return;
+				}
+				const state = await workspaceUpgrade.upgrade();
+				writeJson(response, 202, {
+					accepted: true,
+					upgradeId: state.upgradeId,
+					sessions: state.sessions.length
+				});
+			} catch (error) {
+				writeJson(response, error instanceof WorkspaceUpgradeError ? error.status : 502, { error: error instanceof Error ? error.message : String(error) });
+			}
+		}
+	}), "dataops-managed: workspace upgrade route");
+	recoverWorkspaceUpgradeAfterBoot(workspaceUpgrade);
+	/**
+	* What the last DataOps answer said about this workspace's credential.
+	*
+	* The settings surfaces need this because a 401 is handled deep inside a call that degrades to
+	* "no data", so the panel renders as if the workspace simply has nothing to show. Reading this
+	* route is how the interface learns the reason is an ended session rather than an empty one.
+	* The recorded state is an observation, never an authority: DataOps still decides.
+	*/
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: AUTH_STATE_PATH,
+		handler: async (request, response) => {
+			if (request.method !== "GET") {
+				response.writeHead(405, {
+					allow: "GET",
+					"content-length": "0"
+				});
+				response.end();
+				return;
+			}
+			writeJson(response, 200, { state: currentAuthState() });
+		}
+	}), "dataops-managed: auth state route");
 	await connectExisting();
 }
 /** Read and parse a JSON request body, tolerating an absent one. */
@@ -1402,4 +2793,4 @@ function writeJson(response, status, body) {
 	response.end(payload);
 }
 //#endregion
-export { Config, DEFAULT_TOOL_CALL_TIMEOUT_MS, MANAGED_AUTH_PATH, MANAGED_PLUGIN_ID, MODEL_SYNC_PATH, SKILL_PLAZA_PATH, TOOL_TIMEOUT_MAX_SECONDS, TOOL_TIMEOUT_MIN_SECONDS, TOOL_TIMEOUT_PATH, WORKSPACE_LIMITS_PATH, apply, currentModelSync, currentSettingsSync, currentSkillPlaza, currentWorkspaceLimits, inject, name };
+export { AUTH_STATE_PATH, Config, DEFAULT_TOOL_CALL_TIMEOUT_MS, DEPARTMENTS_PATH, MANAGED_AUTH_PATH, MANAGED_PLUGIN_ID, MODEL_SYNC_PATH, RBAC_PATH, REVIEW_ACTION_PATH, REVIEW_CONTEXT_PATH, REVIEW_NOTIFICATIONS_PATH, REVIEW_SETTINGS_PATH, SKILL_PLAZA_PATH, TOOL_TIMEOUT_MAX_SECONDS, TOOL_TIMEOUT_MIN_SECONDS, TOOL_TIMEOUT_PATH, WORKSPACE_LIMITS_PATH, WORKSPACE_UPGRADE_PATH, adoptRequestJwt, apply, currentModelSync, currentSettingsSync, currentSkillPlaza, currentWorkspaceLimits, inject, name };