@cleocode/adapters 2026.4.129 → 2026.4.130

package/dist/index.js

@@ -1045,6 +1045,66 @@ var init_session2 = __esm({
   }
 });
 
+// packages/contracts/src/session-journal.ts
+import { z as z4 } from "zod";
+var SESSION_JOURNAL_SCHEMA_VERSION, sessionJournalDoctorSummarySchema, sessionJournalDebriefSummarySchema, sessionJournalEntrySchema;
+var init_session_journal = __esm({
+  "packages/contracts/src/session-journal.ts"() {
+    "use strict";
+    SESSION_JOURNAL_SCHEMA_VERSION = "1.0";
+    sessionJournalDoctorSummarySchema = z4.object({
+      /** `true` when zero noise patterns were detected. */
+      isClean: z4.boolean(),
+      /** Total number of noise findings across all patterns. */
+      findingsCount: z4.number().int().nonnegative(),
+      /** Pattern names that were detected (empty when isClean). */
+      patterns: z4.array(z4.string()),
+      /** Total brain entries scanned. `0` = empty or unavailable. */
+      totalScanned: z4.number().int().nonnegative()
+    });
+    sessionJournalDebriefSummarySchema = z4.object({
+      /** First 200 characters of the session end note (if provided). */
+      noteExcerpt: z4.string().max(200).optional(),
+      /** Number of tasks completed during the session. */
+      tasksCompletedCount: z4.number().int().nonnegative(),
+      /** Up to 5 task IDs (not titles) that were the focus of the session. */
+      tasksFocused: z4.array(z4.string()).max(5).optional()
+    });
+    sessionJournalEntrySchema = z4.object({
+      // Identity
+      /** Schema version for forward-compatibility. Always `'1.0'` in this release. */
+      schemaVersion: z4.literal(SESSION_JOURNAL_SCHEMA_VERSION),
+      /** ISO 8601 timestamp when the entry was written. */
+      timestamp: z4.string(),
+      /** CLEO session ID (e.g. `ses_20260424055456_ede571`). */
+      sessionId: z4.string(),
+      /** Event type that triggered this journal entry. */
+      eventType: z4.enum(["session_start", "session_end", "observation", "decision", "error"]),
+      // Session metadata (set on session_start / session_end)
+      /** Agent identifier (e.g. `cleo-prime`, `claude-code`). */
+      agentIdentifier: z4.string().optional(),
+      /** Provider adapter ID active for this session. */
+      providerId: z4.string().optional(),
+      /** Session scope string (e.g. `'global'` or `'epic:T1263'`). */
+      scope: z4.string().optional(),
+      // Session-end fields
+      /** Duration of the session in seconds (session_end only). */
+      duration: z4.number().int().nonnegative().optional(),
+      /** Task IDs (not titles) completed during the session. */
+      tasksCompleted: z4.array(z4.string()).optional(),
+      // Doctor summary (T1262 absorbed)
+      /** Compact result of `scanBrainNoise` run at session-end. */
+      doctorSummary: sessionJournalDoctorSummarySchema.optional(),
+      // Debrief summary
+      /** Compact excerpt from session debrief data. */
+      debriefSummary: sessionJournalDebriefSummarySchema.optional(),
+      // Optional hash chain
+      /** SHA-256 hex of the previous entry's raw JSON string (for integrity chain). */
+      prevEntryHash: z4.string().optional()
+    });
+  }
+});
+
 // packages/contracts/src/status-registry.ts
 var init_status_registry = __esm({
   "packages/contracts/src/status-registry.ts"() {
@@ -1053,52 +1113,52 @@ var init_status_registry = __esm({
 });
 
 // packages/contracts/src/task-evidence.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var fileEvidenceSchema, logEvidenceSchema, screenshotEvidenceSchema, testOutputEvidenceSchema, commandOutputEvidenceSchema, taskEvidenceSchema;
 var init_task_evidence = __esm({
   "packages/contracts/src/task-evidence.ts"() {
     "use strict";
-    fileEvidenceSchema = z4.object({
-      kind: z4.literal("file"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      path: z4.string().min(1),
-      mime: z4.string().optional(),
-      description: z4.string().optional()
+    fileEvidenceSchema = z5.object({
+      kind: z5.literal("file"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      path: z5.string().min(1),
+      mime: z5.string().optional(),
+      description: z5.string().optional()
     });
-    logEvidenceSchema = z4.object({
-      kind: z4.literal("log"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      source: z4.string().min(1),
-      description: z4.string().optional()
+    logEvidenceSchema = z5.object({
+      kind: z5.literal("log"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      source: z5.string().min(1),
+      description: z5.string().optional()
     });
-    screenshotEvidenceSchema = z4.object({
-      kind: z4.literal("screenshot"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      mime: z4.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
-      description: z4.string().optional()
+    screenshotEvidenceSchema = z5.object({
+      kind: z5.literal("screenshot"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      mime: z5.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
+      description: z5.string().optional()
     });
-    testOutputEvidenceSchema = z4.object({
-      kind: z4.literal("test-output"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      passed: z4.number().int().nonnegative(),
-      failed: z4.number().int().nonnegative(),
-      skipped: z4.number().int().nonnegative(),
-      exitCode: z4.number().int(),
-      description: z4.string().optional()
+    testOutputEvidenceSchema = z5.object({
+      kind: z5.literal("test-output"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      passed: z5.number().int().nonnegative(),
+      failed: z5.number().int().nonnegative(),
+      skipped: z5.number().int().nonnegative(),
+      exitCode: z5.number().int(),
+      description: z5.string().optional()
     });
-    commandOutputEvidenceSchema = z4.object({
-      kind: z4.literal("command-output"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      cmd: z4.string().min(1),
-      exitCode: z4.number().int(),
-      description: z4.string().optional()
+    commandOutputEvidenceSchema = z5.object({
+      kind: z5.literal("command-output"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      cmd: z5.string().min(1),
+      exitCode: z5.number().int(),
+      description: z5.string().optional()
     });
-    taskEvidenceSchema = z4.discriminatedUnion("kind", [
+    taskEvidenceSchema = z5.discriminatedUnion("kind", [
       fileEvidenceSchema,
       logEvidenceSchema,
       screenshotEvidenceSchema,
@@ -1123,6 +1183,7 @@ var init_src = __esm({
     init_params();
     init_peer();
     init_session2();
+    init_session_journal();
     init_status_registry();
     init_task_evidence();
   }
@@ -15111,7 +15172,7 @@ function resolveRef(ref, ctx) {
 function convertBaseSchema(schema, ctx) {
   if (schema.not !== void 0) {
     if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
-      return z5.never();
+      return z6.never();
     }
     throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
@@ -15133,7 +15194,7 @@ function convertBaseSchema(schema, ctx) {
       return ctx.refs.get(refPath);
     }
     if (ctx.processing.has(refPath)) {
-      return z5.lazy(() => {
+      return z6.lazy(() => {
         if (!ctx.refs.has(refPath)) {
           throw new Error(`Circular reference not resolved: ${refPath}`);
         }
@@ -15150,25 +15211,25 @@ function convertBaseSchema(schema, ctx) {
   if (schema.enum !== void 0) {
     const enumValues = schema.enum;
     if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
-      return z5.null();
+      return z6.null();
     }
     if (enumValues.length === 0) {
-      return z5.never();
+      return z6.never();
     }
     if (enumValues.length === 1) {
-      return z5.literal(enumValues[0]);
+      return z6.literal(enumValues[0]);
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z5.enum(enumValues);
+      return z6.enum(enumValues);
     }
-    const literalSchemas = enumValues.map((v) => z5.literal(v));
+    const literalSchemas = enumValues.map((v) => z6.literal(v));
     if (literalSchemas.length < 2) {
       return literalSchemas[0];
     }
-    return z5.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+    return z6.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
   if (schema.const !== void 0) {
-    return z5.literal(schema.const);
+    return z6.literal(schema.const);
   }
   const type = schema.type;
   if (Array.isArray(type)) {
@@ -15177,68 +15238,68 @@ function convertBaseSchema(schema, ctx) {
       return convertBaseSchema(typeSchema, ctx);
     });
     if (typeSchemas.length === 0) {
-      return z5.never();
+      return z6.never();
     }
     if (typeSchemas.length === 1) {
       return typeSchemas[0];
     }
-    return z5.union(typeSchemas);
+    return z6.union(typeSchemas);
   }
   if (!type) {
-    return z5.any();
+    return z6.any();
   }
   let zodSchema2;
   switch (type) {
     case "string": {
-      let stringSchema = z5.string();
+      let stringSchema = z6.string();
       if (schema.format) {
         const format = schema.format;
         if (format === "email") {
-          stringSchema = stringSchema.check(z5.email());
+          stringSchema = stringSchema.check(z6.email());
         } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z5.url());
+          stringSchema = stringSchema.check(z6.url());
         } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z5.uuid());
+          stringSchema = stringSchema.check(z6.uuid());
         } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z5.iso.datetime());
+          stringSchema = stringSchema.check(z6.iso.datetime());
         } else if (format === "date") {
-          stringSchema = stringSchema.check(z5.iso.date());
+          stringSchema = stringSchema.check(z6.iso.date());
         } else if (format === "time") {
-          stringSchema = stringSchema.check(z5.iso.time());
+          stringSchema = stringSchema.check(z6.iso.time());
         } else if (format === "duration") {
-          stringSchema = stringSchema.check(z5.iso.duration());
+          stringSchema = stringSchema.check(z6.iso.duration());
         } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z5.ipv4());
+          stringSchema = stringSchema.check(z6.ipv4());
         } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z5.ipv6());
+          stringSchema = stringSchema.check(z6.ipv6());
         } else if (format === "mac") {
-          stringSchema = stringSchema.check(z5.mac());
+          stringSchema = stringSchema.check(z6.mac());
         } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z5.cidrv4());
+          stringSchema = stringSchema.check(z6.cidrv4());
         } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z5.cidrv6());
+          stringSchema = stringSchema.check(z6.cidrv6());
         } else if (format === "base64") {
-          stringSchema = stringSchema.check(z5.base64());
+          stringSchema = stringSchema.check(z6.base64());
         } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z5.base64url());
+          stringSchema = stringSchema.check(z6.base64url());
         } else if (format === "e164") {
-          stringSchema = stringSchema.check(z5.e164());
+          stringSchema = stringSchema.check(z6.e164());
         } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z5.jwt());
+          stringSchema = stringSchema.check(z6.jwt());
         } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z5.emoji());
+          stringSchema = stringSchema.check(z6.emoji());
         } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z5.nanoid());
+          stringSchema = stringSchema.check(z6.nanoid());
         } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z5.cuid());
+          stringSchema = stringSchema.check(z6.cuid());
         } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z5.cuid2());
+          stringSchema = stringSchema.check(z6.cuid2());
         } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z5.ulid());
+          stringSchema = stringSchema.check(z6.ulid());
         } else if (format === "xid") {
-          stringSchema = stringSchema.check(z5.xid());
+          stringSchema = stringSchema.check(z6.xid());
         } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z5.ksuid());
+          stringSchema = stringSchema.check(z6.ksuid());
         }
       }
       if (typeof schema.minLength === "number") {
@@ -15255,7 +15316,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type === "integer" ? z5.number().int() : z5.number();
+      let numberSchema = type === "integer" ? z6.number().int() : z6.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -15279,11 +15340,11 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     case "boolean": {
-      zodSchema2 = z5.boolean();
+      zodSchema2 = z6.boolean();
       break;
     }
     case "null": {
-      zodSchema2 = z5.null();
+      zodSchema2 = z6.null();
       break;
     }
     case "object": {
@@ -15296,14 +15357,14 @@ function convertBaseSchema(schema, ctx) {
       }
       if (schema.propertyNames) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
-        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z5.any();
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z6.any();
         if (Object.keys(shape).length === 0) {
-          zodSchema2 = z5.record(keySchema, valueSchema);
+          zodSchema2 = z6.record(keySchema, valueSchema);
           break;
         }
-        const objectSchema2 = z5.object(shape).passthrough();
-        const recordSchema = z5.looseRecord(keySchema, valueSchema);
-        zodSchema2 = z5.intersection(objectSchema2, recordSchema);
+        const objectSchema2 = z6.object(shape).passthrough();
+        const recordSchema = z6.looseRecord(keySchema, valueSchema);
+        zodSchema2 = z6.intersection(objectSchema2, recordSchema);
         break;
       }
       if (schema.patternProperties) {
@@ -15312,28 +15373,28 @@ function convertBaseSchema(schema, ctx) {
         const looseRecords = [];
         for (const pattern of patternKeys) {
           const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z5.string().regex(new RegExp(pattern));
-          looseRecords.push(z5.looseRecord(keySchema, patternValue));
+          const keySchema = z6.string().regex(new RegExp(pattern));
+          looseRecords.push(z6.looseRecord(keySchema, patternValue));
         }
         const schemasToIntersect = [];
         if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z5.object(shape).passthrough());
+          schemasToIntersect.push(z6.object(shape).passthrough());
         }
         schemasToIntersect.push(...looseRecords);
         if (schemasToIntersect.length === 0) {
-          zodSchema2 = z5.object({}).passthrough();
+          zodSchema2 = z6.object({}).passthrough();
         } else if (schemasToIntersect.length === 1) {
           zodSchema2 = schemasToIntersect[0];
         } else {
-          let result = z5.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          let result = z6.intersection(schemasToIntersect[0], schemasToIntersect[1]);
           for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z5.intersection(result, schemasToIntersect[i]);
+            result = z6.intersection(result, schemasToIntersect[i]);
           }
           zodSchema2 = result;
         }
         break;
       }
-      const objectSchema = z5.object(shape);
+      const objectSchema = z6.object(shape);
       if (schema.additionalProperties === false) {
         zodSchema2 = objectSchema.strict();
       } else if (typeof schema.additionalProperties === "object") {
@@ -15350,33 +15411,33 @@ function convertBaseSchema(schema, ctx) {
         const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
         const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z5.tuple(tupleItems).rest(rest);
+          zodSchema2 = z6.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z5.tuple(tupleItems);
+          zodSchema2 = z6.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z5.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z6.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z5.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z6.maxLength(schema.maxItems));
         }
       } else if (Array.isArray(items)) {
         const tupleItems = items.map((item) => convertSchema(item, ctx));
         const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
         if (rest) {
-          zodSchema2 = z5.tuple(tupleItems).rest(rest);
+          zodSchema2 = z6.tuple(tupleItems).rest(rest);
         } else {
-          zodSchema2 = z5.tuple(tupleItems);
+          zodSchema2 = z6.tuple(tupleItems);
         }
         if (typeof schema.minItems === "number") {
-          zodSchema2 = zodSchema2.check(z5.minLength(schema.minItems));
+          zodSchema2 = zodSchema2.check(z6.minLength(schema.minItems));
         }
         if (typeof schema.maxItems === "number") {
-          zodSchema2 = zodSchema2.check(z5.maxLength(schema.maxItems));
+          zodSchema2 = zodSchema2.check(z6.maxLength(schema.maxItems));
         }
       } else if (items !== void 0) {
         const element = convertSchema(items, ctx);
-        let arraySchema = z5.array(element);
+        let arraySchema = z6.array(element);
         if (typeof schema.minItems === "number") {
           arraySchema = arraySchema.min(schema.minItems);
         }
@@ -15385,7 +15446,7 @@ function convertBaseSchema(schema, ctx) {
         }
         zodSchema2 = arraySchema;
       } else {
-        zodSchema2 = z5.array(z5.any());
+        zodSchema2 = z6.array(z6.any());
       }
       break;
     }
@@ -15402,37 +15463,37 @@ function convertBaseSchema(schema, ctx) {
 }
 function convertSchema(schema, ctx) {
   if (typeof schema === "boolean") {
-    return schema ? z5.any() : z5.never();
+    return schema ? z6.any() : z6.never();
   }
   let baseSchema = convertBaseSchema(schema, ctx);
   const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
   if (schema.anyOf && Array.isArray(schema.anyOf)) {
     const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-    const anyOfUnion = z5.union(options);
-    baseSchema = hasExplicitType ? z5.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+    const anyOfUnion = z6.union(options);
+    baseSchema = hasExplicitType ? z6.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z5.xor(options);
-    baseSchema = hasExplicitType ? z5.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+    const oneOfUnion = z6.xor(options);
+    baseSchema = hasExplicitType ? z6.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf)) {
     if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z5.any();
+      baseSchema = hasExplicitType ? baseSchema : z6.any();
     } else {
       let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
       const startIdx = hasExplicitType ? 0 : 1;
       for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z5.intersection(result, convertSchema(schema.allOf[i], ctx));
+        result = z6.intersection(result, convertSchema(schema.allOf[i], ctx));
       }
       baseSchema = result;
     }
   }
   if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z5.nullable(baseSchema);
+    baseSchema = z6.nullable(baseSchema);
   }
   if (schema.readOnly === true) {
-    baseSchema = z5.readonly(baseSchema);
+    baseSchema = z6.readonly(baseSchema);
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
@@ -15459,7 +15520,7 @@ function convertSchema(schema, ctx) {
 }
 function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
-    return schema ? z5.any() : z5.never();
+    return schema ? z6.any() : z6.never();
   }
   const version2 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
@@ -15473,14 +15534,14 @@ function fromJSONSchema(schema, params) {
   };
   return convertSchema(schema, ctx);
 }
-var z5, RECOGNIZED_KEYS;
+var z6, RECOGNIZED_KEYS;
 var init_from_json_schema = __esm({
   "node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/from-json-schema.js"() {
     init_registries();
     init_checks2();
     init_iso();
     init_schemas2();
-    z5 = {
+    z6 = {
       ...schemas_exports2,
       ...checks_exports2,
       iso: iso_exports