@akagilnc/pi-workflow-roles 0.1.5368 → 0.1.5382

package/dist/gleaner-left-contracts.js

@@ -1,4 +1,20 @@
+import { Type } from "typebox";
+import { openToolObject } from "./open-tool-schema.js";
+import { withTerminatingOutputDeclarations } from "./package-contracts/terminating-infrastructure.js";
+import { isRecord } from "./unknown-value.js";
 const GLEANER_LEFT_OUTPUT_TOOL_NAME = "ak_gleaner_left_output";
+const gleanerLeftOutputSchema = withTerminatingOutputDeclarations(
+  openToolObject(
+    Type.Object({
+      status: Type.Unknown({
+        description: "completed"
+      }),
+      findings: Type.Unknown({
+        description: "\u5F39\u7AE0\u5217\u8868\uFF1B\u6BCF\u6761\u53EF\u542B pointer\uFF08\u6587\u4EF6/\u884C\u6307\u9488\uFF09\u4E0E statement\uFF08\u7591\u70B9\u9648\u8FF0\uFF09\uFF0C\u539F\u6837\u7559\u5B58\u3002\u7A7A\u5217\u8868\u5408\u6CD5\u5B8C\u5C40\uFF1B\u673A\u5668\u4E0D\u5224\u5F39\u7AE0\u662F\u5426\u6210\u7ACB\u3002"
+      })
+    })
+  )
+);
 const GLEANER_LEFT_BASE_FLAG = {
   name: "ak-gleaner-left-base",
   definition: {
@@ -7,7 +23,7 @@ const GLEANER_LEFT_BASE_FLAG = {
   }
 };
 function validateRecordedGleanerLeftOutput(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+  if (!isRecord(value)) {
     throw new Error("Gleaner-left output has no execution discriminator");
   }
   let status;
@@ -24,5 +40,6 @@ function validateRecordedGleanerLeftOutput(value) {
 export {
   GLEANER_LEFT_BASE_FLAG,
   GLEANER_LEFT_OUTPUT_TOOL_NAME,
+  gleanerLeftOutputSchema,
   validateRecordedGleanerLeftOutput
 };

package/dist/headless-host/description.js

@@ -1,3 +1,4 @@
+import { isRecord } from "../unknown-value.js";
 export function isClaudePrintDescription(description) {
     return description.protocol === "claude-print";
 }
@@ -89,7 +90,7 @@ const CODEX_JSON_VALUE_SCHEMA = Object.freeze({
  */
 export function closeJsonSchemaForCodex(schema) {
     const closed = closeSchemaNode(schema);
-    const existingDefs = isPlainObject(closed.$defs)
+    const existingDefs = isRecord(closed.$defs)
         ? closed.$defs
         : {};
     return {
@@ -100,13 +101,9 @@ export function closeJsonSchemaForCodex(schema) {
         },
     };
 }
-/** Shared plain-object guard for headless host schema/event reduction. */
-export function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /** Pure null leaf only — composite type|null is stripped in-leaf, not dropped whole. */
 function isPureNullTypeSchema(value) {
-    if (!isPlainObject(value))
+    if (!isRecord(value))
         return false;
     if (value.type === "null")
         return true;
@@ -120,7 +117,7 @@ function isPureNullTypeSchema(value) {
  * Required edges keep the non-null type(s); optional edges re-add null once.
  */
 function stripNullFromLeafType(leaf) {
-    if (!isPlainObject(leaf) || !Array.isArray(leaf.type))
+    if (!isRecord(leaf) || !Array.isArray(leaf.type))
         return leaf;
     const nonNull = leaf.type.filter((t) => t !== "null");
     if (nonNull.length === leaf.type.length)
@@ -137,7 +134,7 @@ function stripNullFromLeafType(leaf) {
  * lack `type`; strict structured output rejects those intermediate nodes.
  */
 function flattenUnionLeaves(schema) {
-    if (!isPlainObject(schema))
+    if (!isRecord(schema))
         return [schema];
     if (Array.isArray(schema.anyOf)) {
         return schema.anyOf.flatMap(flattenUnionLeaves);
@@ -155,7 +152,7 @@ function nonNullLeaves(schema) {
  * Required → closed non-null leaf(s). Optional → closed leaf(s) + null.
  */
 function closePropertySchema(schema, optional) {
-    const description = isPlainObject(schema) && typeof schema.description === "string"
+    const description = isRecord(schema) && typeof schema.description === "string"
         ? { description: schema.description }
         : {};
     const leaves = nonNullLeaves(schema).map(closeSchemaNode);
@@ -165,10 +162,10 @@ function closePropertySchema(schema, optional) {
         const closed = leaves.length === 1 ? leaves[0] : { anyOf: leaves };
         // Codex strict does not allow sibling keys on $ref; put property guidance
         // on an enclosing schema instead of losing it or weakening the free-JSON ref.
-        if (isPlainObject(closed) && typeof closed.$ref === "string") {
+        if (isRecord(closed) && typeof closed.$ref === "string") {
             return { anyOf: [closed], ...description };
         }
-        return isPlainObject(closed) ? { ...closed, ...description } : closed;
+        return isRecord(closed) ? { ...closed, ...description } : closed;
     }
     return { anyOf: [...leaves, { type: "null" }], ...description };
 }
@@ -182,7 +179,7 @@ function ensureTypedLeaf(schema) {
         return schema;
     if (typeof schema.$ref === "string")
         return schema;
-    if (isPlainObject(schema.properties) || schema.additionalProperties !== undefined) {
+    if (isRecord(schema.properties) || schema.additionalProperties !== undefined) {
         return { ...schema, type: "object" };
     }
     if (schema.items !== undefined) {
@@ -211,7 +208,7 @@ function originalRequiredNames(node) {
     return new Set(node.required.filter((item) => typeof item === "string"));
 }
 function closeSchemaNode(node) {
-    if (!isPlainObject(node))
+    if (!isRecord(node))
         return node;
     // Already a ref (free-JSON leaf or pre-existing) — do not retype.
     if (typeof node.$ref === "string")
@@ -229,10 +226,10 @@ function closeSchemaNode(node) {
     if (node.items !== undefined) {
         out.items = closeSchemaNode(node.items);
     }
-    if (isPlainObject(node.$defs)) {
+    if (isRecord(node.$defs)) {
         out.$defs = Object.fromEntries(Object.entries(node.$defs).map(([key, value]) => [key, closeSchemaNode(value)]));
     }
-    const hasProperties = isPlainObject(node.properties);
+    const hasProperties = isRecord(node.properties);
     const isObjectType = node.type === "object"
         || (Array.isArray(node.type) && node.type.includes("object"))
         || hasProperties
@@ -273,11 +270,11 @@ function closeSchemaNode(node) {
 function stringEnvironment(value) {
     const entries = Array.isArray(value)
         ? value.flatMap((item) => {
-            if (!isPlainObject(item) || typeof item.name !== "string" || typeof item.value !== "string")
+            if (!isRecord(item) || typeof item.name !== "string" || typeof item.value !== "string")
                 return [];
             return [[item.name, item.value]];
         })
-        : isPlainObject(value)
+        : isRecord(value)
             ? Object.entries(value).filter((entry) => typeof entry[1] === "string")
             : [];
     return entries.length === 0 ? undefined : Object.fromEntries(entries);