@remembrance-ai/pi-plugin 0.0.0-stage → 0.2.25

package/scripts/private-lesson-approval.mjs

@@ -0,0 +1,200 @@
+import { PRIVATE_EGRESS_TOOL_LANES } from "./private-egress-lanes.mjs";
+
+const PRIVATE_LESSON_LANE = "private_lesson";
+const PRIVATE_SKILL_LANE = "private_skill";
+const PRIVATE_LESSON_SUBMIT_TOOL = "submit_private_lesson_candidate";
+const PER_OPERATION_ADMIN_LANE = "admin_control";
+const PRIVATE_EGRESS_TOOLS = new Set(Object.keys(PRIVATE_EGRESS_TOOL_LANES));
+const PRIVATE_EGRESS_LANES = new Set(Object.values(PRIVATE_EGRESS_TOOL_LANES));
+
+export function handlePrivateLessonSubmitApproval(event, options = {}) {
+  const toolName = String(
+    event?.toolName ?? event?.tool_name ?? "",
+  ).toLowerCase();
+  const exactTool = [...PRIVATE_EGRESS_TOOLS].find((candidate) =>
+    toolName.endsWith(candidate),
+  );
+  const lane = exactTool ? PRIVATE_EGRESS_TOOL_LANES[exactTool] : undefined;
+  if (
+    lane === "conditional_feedback" &&
+    !feedbackContainsReusableContent(event)
+  ) {
+    return undefined;
+  }
+  const approvedLanes = options.approvedLanes ?? options.approvedTools;
+  if (!exactTool || !lane || (lane !== PER_OPERATION_ADMIN_LANE && approvedLanes?.has?.(lane))) {
+    return undefined;
+  }
+  const approval = approvalCopy(lane);
+  return {
+    requireApproval: {
+      title: approval.title,
+      description: approval.description,
+      severity: "warning",
+      allowedDecisions: lane === PER_OPERATION_ADMIN_LANE
+        ? ["allow-once", "deny"]
+        : ["allow-once", "allow-always", "deny"],
+      timeoutMs: 120_000,
+      onResolution(decision) {
+        if (decision === "allow-always" && lane !== PER_OPERATION_ADMIN_LANE) options.onAllowAlways?.(lane);
+      },
+    },
+  };
+}
+
+function feedbackContainsReusableContent(event) {
+  const payload =
+    event?.arguments ??
+    event?.input ??
+    event?.params?.arguments ??
+    event?.params;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return false;
+  }
+  const lesson = payload.lesson;
+  return typeof lesson === "string" && lesson.trim().length > 0;
+}
+
+function approvalCopy(lane) {
+  if (lane === PER_OPERATION_ADMIN_LANE) {
+    return {
+      title: "Approve Remembrance administrator operation",
+      description:
+        "Review this exact admin_write operation and its complete arguments. Approval authorizes this invocation only; it does not approve future administrator writes or change the request_id used to identify the same logical attempt. Saved private-learning approvals do not authorize administrator operations.",
+    };
+  }
+  if (lane === "admin_review_repair") {
+    return {
+      title: "Create protected Remembrance review replacement",
+      description:
+        "Organization admin:review authority required. Send one complete new protected skill replacement to this organization's normal verification and review queue. The original draft is retained unchanged. This does not approve the replacement or close the original; any original disposition requires a separate normal explicit decision after proving an accepted, tenant-readable active replacement. Private-learning approval does not authorize this administrator action.",
+    };
+  }
+  if (lane === PRIVATE_SKILL_LANE) {
+    return {
+      title: "Submit private Remembrance skill",
+      description:
+        "Send one encrypted complete-skill draft to this organization's private verification and review queue. The submission action cannot publish public content.",
+    };
+  }
+  if (lane === "remembrance_submission") {
+    return {
+      title: "Submit broad Remembrance content",
+      description:
+        "Send reusable content through a legacy broad contribution action. Review the complete payload and destination before allowing it.",
+    };
+  }
+  if (lane === "private_skill_proposal") {
+    return {
+      title: "Propose private Remembrance skill",
+      description:
+        "Send a complete skill only to this organization's private review queue. This approval does not authorize public-capable candidate actions.",
+    };
+  }
+  if (lane === "skill_candidate") {
+    return {
+      title: "Propose Remembrance skill candidate",
+      description:
+        "Send a complete skill candidate whose destination depends on the active credential. Review the payload and resulting visibility before allowing it.",
+    };
+  }
+  if (lane === "skill_suggestion") {
+    return {
+      title: "Suggest a Remembrance skill change",
+      description:
+        "Send one proposed change to an existing skill. This approval covers suggestions only.",
+    };
+  }
+  if (lane === "resource_submission") {
+    return {
+      title: "Submit a Remembrance resource",
+      description:
+        "Send one reusable resource candidate. This approval does not authorize skill or review submissions.",
+    };
+  }
+  if (lane === "resource_review") {
+    return {
+      title: "Submit a Remembrance resource review",
+      description:
+        "Send one resource review with bounded redacted evidence. This approval covers reviews only.",
+    };
+  }
+  if (lane === "conditional_feedback") {
+    return {
+      title: "Submit reusable feedback content",
+      description:
+        "Send the reusable lesson attached to this legacy feedback action. Categorical query-fit and post-use feedback do not require this approval.",
+    };
+  }
+  return {
+    title: "Submit private Remembrance lesson",
+    description:
+      "Send one already-redacted canonical lesson to this organization's private verification queue. The submission action cannot publish public content.",
+  };
+}
+
+export function privateLessonSubmitApproved(api) {
+  return privateLearningSubmitApprovals(api).has(PRIVATE_LESSON_LANE);
+}
+
+export function privateLearningSubmitApprovals(api) {
+  const config = asRecord(api?.pluginConfig);
+  const configuredLanes = asRecord(config.privateLearningEgressApprovals);
+  const configuredTools = asRecord(config.privateLearningSubmitApprovals);
+  const approved = new Set(
+    [...PRIVATE_EGRESS_LANES].filter((lane) => lane !== PER_OPERATION_ADMIN_LANE && configuredLanes[lane] === true),
+  );
+  for (const [toolName, lane] of Object.entries(PRIVATE_EGRESS_TOOL_LANES)) {
+    if (lane !== PER_OPERATION_ADMIN_LANE && configuredTools[toolName] === true) approved.add(lane);
+  }
+  if (config.privateLessonSubmitApproval === true) {
+    approved.add(PRIVATE_LESSON_LANE);
+  }
+  return approved;
+}
+
+export async function persistPrivateLessonSubmitApproval(api) {
+  return persistPrivateLearningSubmitApproval(api, PRIVATE_LESSON_SUBMIT_TOOL);
+}
+
+export async function persistPrivateLearningSubmitApproval(api, toolName) {
+  const lane = PRIVATE_EGRESS_LANES.has(toolName)
+    ? toolName
+    : PRIVATE_EGRESS_TOOL_LANES[toolName];
+  if (!lane) {
+    throw new Error("Unsupported private Remembrance submission action.");
+  }
+  if (lane === PER_OPERATION_ADMIN_LANE) {
+    throw new Error("Administrator operations require per-operation approval and cannot persist allow-always consent.");
+  }
+  const mutateConfigFile = api?.runtime?.config?.mutateConfigFile;
+  if (typeof mutateConfigFile !== "function") {
+    throw new Error("OpenClaw config mutation is unavailable.");
+  }
+  await mutateConfigFile({
+    afterWrite: { mode: "auto" },
+    mutate: (draft) => {
+      const plugins = asRecord(draft.plugins);
+      const entries = asRecord(plugins.entries);
+      const entry = asRecord(entries.remembrance);
+      entries.remembrance = {
+        ...entry,
+        config: {
+          ...asRecord(entry.config),
+          privateLearningEgressApprovals: {
+            ...asRecord(asRecord(entry.config).privateLearningEgressApprovals),
+            [lane]: true,
+          },
+        },
+      };
+      plugins.entries = entries;
+      draft.plugins = plugins;
+    },
+  });
+}
+
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+}