@arke-institute/klados-testing 0.1.3 → 0.3.1

package/dist/entities.d.ts

@@ -33,12 +33,19 @@ export declare function deleteEntity(id: string): Promise<void>;
  * Create a new collection
  *
  * Uses POST /collections to get proper owner permissions.
+ * By default, collections include standard roles with public *:view access.
  *
  * @example
  * ```typescript
+ * // Minimal - gets default roles
  * const collection = await createCollection({
  *   label: 'Test Collection',
- *   allowedTypes: ['document'],
+ * });
+ *
+ * // Agent-accessible collection
+ * const agentCollection = await createCollection({
+ *   label: 'Agent Collection',
+ *   roles: { public: ['*:view', '*:invoke'] }
  * });
  * ```
  */

package/dist/entities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../src/entities.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EACV,MAAM,EACN,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;GAWG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAWhF;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAE3D;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ5D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,UAAU,CAAC,CAMrB;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,kBAAkB,CAAC,CAK7B"}
+{"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../src/entities.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EACV,MAAM,EACN,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;GAWG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAWhF;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAE3D;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ5D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,UAAU,CAAC,CAQrB;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,kBAAkB,CAAC,CAK7B"}

package/dist/entities.js

@@ -51,12 +51,19 @@ export async function deleteEntity(id) {
  * Create a new collection
  *
  * Uses POST /collections to get proper owner permissions.
+ * By default, collections include standard roles with public *:view access.
  *
  * @example
  * ```typescript
+ * // Minimal - gets default roles
  * const collection = await createCollection({
  *   label: 'Test Collection',
- *   allowedTypes: ['document'],
+ * });
+ *
+ * // Agent-accessible collection
+ * const agentCollection = await createCollection({
+ *   label: 'Agent Collection',
+ *   roles: { public: ['*:view', '*:invoke'] }
  * });
  * ```
  */
@@ -65,6 +72,8 @@ export async function createCollection(options) {
         label: options.label,
         description: options.description,
         allowed_types: options.allowedTypes,
+        roles: options.roles,
+        use_roles_default: options.useRolesDefault,
     });
 }
 /**

package/dist/entities.js.map

@@ -1 +1 @@
-{"version":3,"file":"entities.js","sourceRoot":"","sources":["../src/entities.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AASzC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,OAA4B;IAC7D,MAAM,IAAI,GAA4B;QACpC,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,UAAU,EAAE,OAAO,CAAC,UAAU;KAC/B,CAAC;IAEF,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;QACzB,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IACzC,CAAC;IAED,OAAO,UAAU,CAAS,MAAM,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;AACvD,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,EAAU;IACxC,OAAO,UAAU,CAAS,KAAK,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,EAAU;IAC3C,0BAA0B;IAC1B,MAAM,GAAG,GAAG,MAAM,UAAU,CAAkB,KAAK,EAAE,aAAa,EAAE,MAAM,CAAC,CAAC;IAE5E,yBAAyB;IACzB,MAAM,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,EAAE,EAAE;QAC5C,UAAU,EAAE,GAAG,CAAC,GAAG;KACpB,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,OAAgC;IAEhC,OAAO,UAAU,CAAa,MAAM,EAAE,cAAc,EAAE;QACpD,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,aAAa,EAAE,OAAO,CAAC,YAAY;KACpC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,YAAoB;IAEpB,OAAO,UAAU,CACf,KAAK,EACL,gBAAgB,YAAY,WAAW,CACxC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"entities.js","sourceRoot":"","sources":["../src/entities.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AASzC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,OAA4B;IAC7D,MAAM,IAAI,GAA4B;QACpC,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,UAAU,EAAE,OAAO,CAAC,UAAU;KAC/B,CAAC;IAEF,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;QACzB,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IACzC,CAAC;IAED,OAAO,UAAU,CAAS,MAAM,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;AACvD,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,EAAU;IACxC,OAAO,UAAU,CAAS,KAAK,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,EAAU;IAC3C,0BAA0B;IAC1B,MAAM,GAAG,GAAG,MAAM,UAAU,CAAkB,KAAK,EAAE,aAAa,EAAE,MAAM,CAAC,CAAC;IAE5E,yBAAyB;IACzB,MAAM,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,EAAE,EAAE;QAC5C,UAAU,EAAE,GAAG,CAAC,GAAG;KACpB,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,OAAgC;IAEhC,OAAO,UAAU,CAAa,MAAM,EAAE,cAAc,EAAE;QACpD,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,aAAa,EAAE,OAAO,CAAC,YAAY;QACnC,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,iBAAiB,EAAE,OAAO,CAAC,eAAe;KAC3C,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,YAAoB;IAEpB,OAAO,UAAU,CACf,KAAK,EACL,gBAAgB,YAAY,WAAW,CACxC,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -53,8 +53,10 @@
  */
 export { configureTestClient, getConfig, resetTestClient, apiRequest, sleep, log } from './client.js';
 export { createEntity, getEntity, deleteEntity, createCollection, getCollectionEntities } from './entities.js';
-export { getKladosLog, getFirstLogFromCollection, waitForKladosLog, getLogMessages, getLogEntry } from './logs.js';
+export { getKladosLog, getFirstLogFromCollection, waitForKladosLog, getLogMessages, getLogEntry, getLogChildren, buildWorkflowTree, waitForWorkflowTree, } from './logs.js';
 export { invokeKlados } from './invoke.js';
+export { invokeRhiza, createRhiza, getWorkflowLogs, waitForWorkflowCompletion, assertWorkflowCompleted, assertWorkflowPath, } from './workflows.js';
 export { assertLogCompleted, assertLogFailed, assertLogHasMessages, assertLogMessageCount, assertLogHasHandoff, } from './assertions.js';
-export type { TestConfig, Entity, Collection, CollectionEntities, InvokeResult, LogMessage, KladosLogEntry, CreateEntityOptions, CreateCollectionOptions, InvokeKladosOptions, WaitForLogOptions, LogMessageCriteria, } from './types.js';
+export type { TestConfig, Entity, Collection, CollectionEntities, InvokeResult, LogMessage, KladosLogEntry, CreateEntityOptions, CreateCollectionOptions, InvokeKladosOptions, WaitForLogOptions, LogMessageCriteria, LogTreeNode, WorkflowLogTree, WaitForWorkflowTreeOptions, } from './types.js';
+export type { InvokeRhizaOptions, InvokeRhizaResult, WorkflowCompletionResult, CreateRhizaOptions, FlowStep, ThenSpec, } from './workflows.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAGH,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAGtG,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAG/G,OAAO,EAAE,YAAY,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAGnH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EACV,UAAU,EACV,MAAM,EACN,UAAU,EACV,kBAAkB,EAClB,YAAY,EACZ,UAAU,EACV,cAAc,EACd,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAGH,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAGtG,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAG/G,OAAO,EACL,YAAY,EACZ,yBAAyB,EACzB,gBAAgB,EAChB,cAAc,EACd,WAAW,EAEX,cAAc,EACd,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,EACL,WAAW,EACX,WAAW,EACX,eAAe,EACf,yBAAyB,EACzB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EACV,UAAU,EACV,MAAM,EACN,UAAU,EACV,kBAAkB,EAClB,YAAY,EACZ,UAAU,EACV,cAAc,EACd,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAElB,WAAW,EACX,eAAe,EACf,0BAA0B,GAC3B,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,kBAAkB,EAClB,iBAAiB,EACjB,wBAAwB,EACxB,kBAAkB,EAClB,QAAQ,EACR,QAAQ,GACT,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -56,9 +56,13 @@ export { configureTestClient, getConfig, resetTestClient, apiRequest, sleep, log
 // Entity operations
 export { createEntity, getEntity, deleteEntity, createCollection, getCollectionEntities } from './entities.js';
 // Log utilities
-export { getKladosLog, getFirstLogFromCollection, waitForKladosLog, getLogMessages, getLogEntry } from './logs.js';
+export { getKladosLog, getFirstLogFromCollection, waitForKladosLog, getLogMessages, getLogEntry, 
+// Tree-based traversal
+getLogChildren, buildWorkflowTree, waitForWorkflowTree, } from './logs.js';
 // Klados invocation
 export { invokeKlados } from './invoke.js';
+// Workflow utilities
+export { invokeRhiza, createRhiza, getWorkflowLogs, waitForWorkflowCompletion, assertWorkflowCompleted, assertWorkflowPath, } from './workflows.js';
 // Assertions
 export { assertLogCompleted, assertLogFailed, assertLogHasMessages, assertLogMessageCount, assertLogHasHandoff, } from './assertions.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,gBAAgB;AAChB,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAEtG,oBAAoB;AACpB,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE/G,gBAAgB;AAChB,OAAO,EAAE,YAAY,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAEnH,oBAAoB;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,aAAa;AACb,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,gBAAgB;AAChB,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAEtG,oBAAoB;AACpB,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE/G,gBAAgB;AAChB,OAAO,EACL,YAAY,EACZ,yBAAyB,EACzB,gBAAgB,EAChB,cAAc,EACd,WAAW;AACX,uBAAuB;AACvB,cAAc,EACd,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,WAAW,CAAC;AAEnB,oBAAoB;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,qBAAqB;AACrB,OAAO,EACL,WAAW,EACX,WAAW,EACX,eAAe,EACf,yBAAyB,EACzB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAExB,aAAa;AACb,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,iBAAiB,CAAC"}

package/dist/invoke.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../src/invoke.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAwBvB"}
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../src/invoke.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CA2BvB"}

package/dist/invoke.js

@@ -26,9 +26,11 @@ import { apiRequest } from './client.js';
 export async function invokeKlados(options) {
     const body = {
         target_collection: options.targetCollection,
-        job_collection: options.jobCollection,
         confirm: options.confirm ?? true,
     };
+    if (options.jobCollection) {
+        body.job_collection = options.jobCollection;
+    }
     if (options.targetEntity) {
         body.target_entity = options.targetEntity;
     }

package/dist/invoke.js.map

@@ -1 +1 @@
-{"version":3,"file":"invoke.js","sourceRoot":"","sources":["../src/invoke.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,OAA4B;IAE5B,MAAM,IAAI,GAA4B;QACpC,iBAAiB,EAAE,OAAO,CAAC,gBAAgB;QAC3C,cAAc,EAAE,OAAO,CAAC,aAAa;QACrC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,IAAI;KACjC,CAAC;IAEF,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;QACzB,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAC5C,CAAC;IAED,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;QAC3B,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAChD,CAAC;IAED,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAClB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC7B,CAAC;IAED,OAAO,UAAU,CACf,MAAM,EACN,WAAW,OAAO,CAAC,QAAQ,SAAS,EACpC,IAAI,CACL,CAAC;AACJ,CAAC"}
+{"version":3,"file":"invoke.js","sourceRoot":"","sources":["../src/invoke.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,OAA4B;IAE5B,MAAM,IAAI,GAA4B;QACpC,iBAAiB,EAAE,OAAO,CAAC,gBAAgB;QAC3C,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,IAAI;KACjC,CAAC;IAEF,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;QAC1B,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;IAC9C,CAAC;IAED,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;QACzB,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAC5C,CAAC;IAED,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;QAC3B,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAChD,CAAC;IAED,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAClB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC7B,CAAC;IAED,OAAO,UAAU,CACf,MAAM,EACN,WAAW,OAAO,CAAC,QAAQ,SAAS,EACpC,IAAI,CACL,CAAC;AACJ,CAAC"}

package/dist/logs.d.ts

@@ -1,7 +1,9 @@
 /**
  * Klados log utilities for testing
+ *
+ * Includes tree-based traversal for multi-step workflows and scatter/gather operations.
  */
-import type { KladosLogEntry, WaitForLogOptions } from './types.js';
+import type { KladosLogEntry, WaitForLogOptions, WorkflowLogTree, WaitForWorkflowTreeOptions } from './types.js';
 /**
  * Get a klados log entry by ID
  *
@@ -75,9 +77,21 @@ export declare function getLogEntry(log: KladosLogEntry): {
     };
     handoffs?: Array<{
         target: string;
-        type: "invoke" | "scatter" | "complete" | "error" | "none";
+        type: "invoke" | "pass" | "scatter" | "gather" | "complete" | "error" | "none";
         job_id?: string;
         error?: string;
+        outputs?: string[];
+        invocations
+        /**
+         * Result of getting log children
+         */
+        ?: Array<{
+            target: string;
+            request?: Record<string, unknown>;
+        }>;
+        delegated?: boolean;
+        dispatch_id?: string;
+        done_slots?: number;
     }>;
     error?: {
         code: string;
@@ -85,4 +99,87 @@ export declare function getLogEntry(log: KladosLogEntry): {
         retryable: boolean;
     };
 };
+/**
+ * Result of getting log children
+ */
+interface LogChildrenResult {
+    /** Array of child log entity IDs */
+    childIds: string[];
+    /** Total count of sent_to relationships (may be more than childIds if some don't exist yet) */
+    sentToCount: number;
+}
+/**
+ * Get children of a log by querying for outgoing sent_to relationships
+ *
+ * In the Rhiza log tree:
+ * - Parents have `sent_to` outgoing relationships pointing to children
+ * - Children have `received_from` outgoing relationships pointing to parents
+ * - We use `sent_to` for traversal since it's an outgoing relationship (no indexing lag)
+ *
+ * @param logEntityId - Log entity ID to find children of
+ * @returns Object with child IDs and total sent_to count
+ */
+export declare function getLogChildren(logEntityId: string): Promise<LogChildrenResult>;
+/**
+ * Build a snapshot of the workflow log tree
+ *
+ * This traverses the log tree starting from the first_log relationship
+ * on the job collection, following incoming received_from relationships
+ * to discover all logs in the workflow.
+ *
+ * @example
+ * ```typescript
+ * const tree = await buildWorkflowTree(jobCollectionId);
+ *
+ * if (tree.isComplete) {
+ *   console.log('Workflow finished with', tree.logs.size, 'logs');
+ *   if (tree.hasErrors) {
+ *     console.log('Errors:', tree.errors);
+ *   }
+ * }
+ * ```
+ *
+ * @param jobCollectionId - Job collection ID
+ * @returns Current state of the workflow log tree
+ */
+export declare function buildWorkflowTree(jobCollectionId: string): Promise<WorkflowLogTree>;
+/**
+ * Wait for a workflow to complete by polling the log tree
+ *
+ * This function properly handles:
+ * - Multi-step workflows (A → B → C)
+ * - Scatter operations (A → [B1, B2, B3])
+ * - Nested scatters
+ * - Gather operations
+ * - Mixed success/error branches
+ *
+ * Unlike `waitForKladosLog` which only checks the first log, this function
+ * traverses the entire log tree and waits for ALL branches to complete.
+ *
+ * @example
+ * ```typescript
+ * // Wait for a scatter workflow to complete
+ * const tree = await waitForWorkflowTree(jobCollectionId, {
+ *   timeout: 60000,
+ *   pollInterval: 2000,
+ * });
+ *
+ * if (tree.isComplete) {
+ *   console.log('All', tree.logs.size, 'logs completed');
+ *   if (tree.hasErrors) {
+ *     console.log('Some branches failed:', tree.errors);
+ *   } else {
+ *     console.log('Workflow succeeded!');
+ *   }
+ * } else {
+ *   console.log('Workflow timed out');
+ * }
+ * ```
+ *
+ * @param jobCollectionId - Job collection ID
+ * @param options - Wait options
+ * @returns Final state of the workflow log tree
+ */
+export declare function waitForWorkflowTree(jobCollectionId: string, options?: WaitForWorkflowTreeOptions): Promise<WorkflowLogTree>;
+export {};
 //# sourceMappingURL=logs.d.ts.map

package/dist/logs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../src/logs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAU,cAAc,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAEzE;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CASxB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,MAAM,EACvB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CA0BhC;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,cAAc,qCAEjD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,cAAc;;;;;;;;qBAvB1B,CAAC;uBAGlB,CAAH;;iBAOU,CAAC;aAA2B,CAAC;;;;;;;;;;cAaD,CAAC;aAC1B,CAAC;;;;;;;EACd"}
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../src/logs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAEV,cAAc,EACd,iBAAiB,EAEjB,eAAe,EACf,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAEzE;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CASxB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,MAAM,EACvB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CA0BhC;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,cAAc,qCAEjD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,cAAc;;;;;;;;qBAzBzC,CADG;uBAAmC,CAAC;;iBAGZ,CAAC;aAG9B,CAAC;;;;;;;;;;cAkBE,CAAC;aAAyB,CAAC;eAMxB,CAAC;;QAIX;;WAEG;QACH,CALA;;mBAAyD,CAAC;;iBAM5B,CAAC;mBAEuB,CAAC;kBAKtB,CAAC;;;;;;;EAjBjC;AAMD;;GAEG;AACH,UAAU,iBAAiB;IACzB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,+FAA+F;IAC/F,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAiBpF;AAyMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,iBAAiB,CACrC,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,eAAe,CAAC,CAoE1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,mBAAmB,CACvC,eAAe,EAAE,MAAM,EACvB,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC,eAAe,CAAC,CAyD1B"}

package/dist/logs.js

@@ -1,5 +1,7 @@
 /**
  * Klados log utilities for testing
+ *
+ * Includes tree-based traversal for multi-step workflows and scatter/gather operations.
  */
 import { apiRequest, sleep } from './client.js';
 /**
@@ -89,4 +91,383 @@ export function getLogMessages(log) {
 export function getLogEntry(log) {
     return log.properties.log_data.entry;
 }
+/**
+ * Get children of a log by querying for outgoing sent_to relationships
+ *
+ * In the Rhiza log tree:
+ * - Parents have `sent_to` outgoing relationships pointing to children
+ * - Children have `received_from` outgoing relationships pointing to parents
+ * - We use `sent_to` for traversal since it's an outgoing relationship (no indexing lag)
+ *
+ * @param logEntityId - Log entity ID to find children of
+ * @returns Object with child IDs and total sent_to count
+ */
+export async function getLogChildren(logEntityId) {
+    try {
+        const entity = await apiRequest('GET', `/entities/${logEntityId}`);
+        // Look for sent_to relationships pointing to children
+        // Note: GET /entities/{id} only returns outgoing relationships,
+        // so no direction check is needed.
+        const sentToRels = entity.relationships?.filter((r) => r.predicate === 'sent_to') ?? [];
+        const childIds = sentToRels.map((r) => r.peer);
+        return {
+            childIds,
+            sentToCount: sentToRels.length,
+        };
+    }
+    catch {
+        return { childIds: [], sentToCount: 0 };
+    }
+}
+/**
+ * Extract expected children count from log messages
+ *
+ * Scatter workers log numCopies in their success message metadata.
+ * This is the most reliable source for expected children count.
+ *
+ * @param log - Log entry to analyze
+ * @returns Number of expected children from messages, or null if not found
+ */
+function extractExpectedChildrenFromMessages(log) {
+    const messages = log.properties.log_data.messages ?? [];
+    for (const msg of messages) {
+        // Check for numCopies in message metadata (from scatter worker)
+        if (msg.metadata?.numCopies !== undefined) {
+            return msg.metadata.numCopies;
+        }
+    }
+    return null;
+}
+/**
+ * Calculate expected children count from handoffs
+ *
+ * Priority:
+ * 1. numCopies from log messages (worker-provided, legacy support)
+ * 2. outputs array from handoff record (framework-provided, most reliable)
+ * 3. invocations array length (for local scatters without outputs field)
+ * 4. Handoff type analysis (pass = 1, etc.)
+ *
+ * @param log - Log entry to analyze
+ * @returns Number of expected children, or -1 if unknown (keep polling)
+ */
+function getExpectedChildrenCount(log) {
+    // First, check log messages for numCopies (from scatter worker - legacy support)
+    const numCopies = extractExpectedChildrenFromMessages(log);
+    if (numCopies !== null) {
+        return numCopies;
+    }
+    // Fall back to handoff analysis
+    const entry = log.properties.log_data.entry;
+    const handoffs = entry.handoffs ?? [];
+    if (handoffs.length === 0) {
+        return 0; // No handoffs = leaf node
+    }
+    let total = 0;
+    for (const handoff of handoffs) {
+        if (handoff.type === 'invoke' || handoff.type === 'pass') {
+            // Invoke/pass creates 1 child
+            total += 1;
+        }
+        else if (handoff.type === 'scatter') {
+            // Scatter creates N children
+            // Priority: outputs array (framework-provided) > invocations > unknown
+            if (handoff.outputs && handoff.outputs.length > 0) {
+                // Use outputs array - this is the most reliable source
+                // Subtract done_slots since those don't create children
+                const doneSlots = handoff.done_slots ?? 0;
+                total += handoff.outputs.length - doneSlots;
+            }
+            else if (handoff.invocations && handoff.invocations.length > 0) {
+                // Use invocations array for local scatters (legacy)
+                total += handoff.invocations.length;
+            }
+            else if (handoff.delegated) {
+                // Delegated scatter without outputs field (shouldn't happen with new code)
+                // Return -1 to indicate we need to keep polling
+                total = -1;
+                break;
+            }
+            else {
+                // Fallback: expect at least 1 child
+                total += 1;
+            }
+        }
+        else if (handoff.type === 'gather') {
+            // Gather creates 1 child (the gather target)
+            total += 1;
+        }
+        // Other types = 0 children
+    }
+    return total;
+}
+/**
+ * Build a log tree node recursively
+ *
+ * @param logEntityId - Entity ID of the log
+ * @param logsMap - Map to collect all discovered logs
+ * @param visited - Set of visited log IDs to prevent cycles
+ */
+async function buildTreeNode(logEntityId, logsMap, visited) {
+    if (visited.has(logEntityId)) {
+        // Prevent infinite loops on malformed data
+        const existingLog = logsMap.get(logEntityId);
+        if (existingLog) {
+            return {
+                log: existingLog,
+                children: [],
+                isLeaf: true,
+                isTerminal: existingLog.properties.status === 'done' ||
+                    existingLog.properties.status === 'error',
+                expectedChildren: 0,
+            };
+        }
+        return null;
+    }
+    visited.add(logEntityId);
+    // Fetch the log entry
+    let log;
+    try {
+        log = await getKladosLog(logEntityId);
+        logsMap.set(logEntityId, log);
+    }
+    catch {
+        // Log doesn't exist yet or fetch failed
+        return null;
+    }
+    const isTerminal = log.properties.status === 'done' || log.properties.status === 'error';
+    // Find children via sent_to relationships
+    const { childIds } = await getLogChildren(logEntityId);
+    // Get expected children count (from log messages or handoff analysis)
+    const expectedChildren = getExpectedChildrenCount(log);
+    // Recursively build child nodes
+    const children = [];
+    for (const childId of childIds) {
+        const childNode = await buildTreeNode(childId, logsMap, visited);
+        if (childNode) {
+            children.push(childNode);
+        }
+    }
+    // A node is a leaf if it's terminal AND has no expected children
+    // OR if it has error status (errors stop the branch)
+    const isLeaf = log.properties.status === 'error' ||
+        (isTerminal && expectedChildren === 0);
+    return {
+        log,
+        children,
+        isLeaf,
+        isTerminal,
+        expectedChildren,
+    };
+}
+/**
+ * Collect all leaf nodes from a tree
+ */
+function collectLeaves(node) {
+    if (node.children.length === 0) {
+        return [node];
+    }
+    return node.children.flatMap(collectLeaves);
+}
+/**
+ * Check if all expected children have been discovered in the tree
+ *
+ * Returns false if:
+ * - We don't know how many children to expect (expectedChildren === -1)
+ * - We have fewer children than expected
+ * - Any child hasn't discovered all its children (recursive)
+ */
+function checkAllChildrenDiscovered(node) {
+    // If node is still running, children may not exist yet - assume OK for now
+    if (!node.isTerminal) {
+        return true;
+    }
+    // If we don't know expected children count, keep polling
+    if (node.expectedChildren < 0) {
+        return false;
+    }
+    // If we have fewer children than expected, not complete
+    if (node.children.length < node.expectedChildren) {
+        return false;
+    }
+    // Recursively check all children
+    for (const child of node.children) {
+        if (!checkAllChildrenDiscovered(child)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Build a snapshot of the workflow log tree
+ *
+ * This traverses the log tree starting from the first_log relationship
+ * on the job collection, following incoming received_from relationships
+ * to discover all logs in the workflow.
+ *
+ * @example
+ * ```typescript
+ * const tree = await buildWorkflowTree(jobCollectionId);
+ *
+ * if (tree.isComplete) {
+ *   console.log('Workflow finished with', tree.logs.size, 'logs');
+ *   if (tree.hasErrors) {
+ *     console.log('Errors:', tree.errors);
+ *   }
+ * }
+ * ```
+ *
+ * @param jobCollectionId - Job collection ID
+ * @returns Current state of the workflow log tree
+ */
+export async function buildWorkflowTree(jobCollectionId) {
+    const logsMap = new Map();
+    const visited = new Set();
+    // Find root via first_log relationship
+    const firstLogId = await getFirstLogFromCollection(jobCollectionId);
+    if (!firstLogId) {
+        return {
+            root: null,
+            logs: logsMap,
+            isComplete: false,
+            hasErrors: false,
+            leaves: [],
+            errors: [],
+            allChildrenDiscovered: false,
+        };
+    }
+    // Build tree starting from root
+    const root = await buildTreeNode(firstLogId, logsMap, visited);
+    if (!root) {
+        return {
+            root: null,
+            logs: logsMap,
+            isComplete: false,
+            hasErrors: false,
+            leaves: [],
+            errors: [],
+            allChildrenDiscovered: false,
+        };
+    }
+    // Collect leaves and analyze tree
+    const leaves = collectLeaves(root);
+    const allChildrenDiscovered = checkAllChildrenDiscovered(root);
+    // Workflow is complete when:
+    // 1. All leaves are terminal (done or error)
+    // 2. All expected children have been discovered
+    const allLeavesTerminal = leaves.every((leaf) => leaf.isTerminal);
+    const isComplete = allLeavesTerminal && allChildrenDiscovered;
+    // Collect errors
+    const errors = [];
+    for (const log of logsMap.values()) {
+        if (log.properties.status === 'error') {
+            const entry = log.properties.log_data.entry;
+            if (entry.error) {
+                errors.push({
+                    logId: log.id,
+                    kladosId: log.properties.klados_id,
+                    error: entry.error,
+                });
+            }
+        }
+    }
+    return {
+        root,
+        logs: logsMap,
+        isComplete,
+        hasErrors: errors.length > 0,
+        leaves,
+        errors,
+        allChildrenDiscovered,
+    };
+}
+/**
+ * Wait for a workflow to complete by polling the log tree
+ *
+ * This function properly handles:
+ * - Multi-step workflows (A → B → C)
+ * - Scatter operations (A → [B1, B2, B3])
+ * - Nested scatters
+ * - Gather operations
+ * - Mixed success/error branches
+ *
+ * Unlike `waitForKladosLog` which only checks the first log, this function
+ * traverses the entire log tree and waits for ALL branches to complete.
+ *
+ * @example
+ * ```typescript
+ * // Wait for a scatter workflow to complete
+ * const tree = await waitForWorkflowTree(jobCollectionId, {
+ *   timeout: 60000,
+ *   pollInterval: 2000,
+ * });
+ *
+ * if (tree.isComplete) {
+ *   console.log('All', tree.logs.size, 'logs completed');
+ *   if (tree.hasErrors) {
+ *     console.log('Some branches failed:', tree.errors);
+ *   } else {
+ *     console.log('Workflow succeeded!');
+ *   }
+ * } else {
+ *   console.log('Workflow timed out');
+ * }
+ * ```
+ *
+ * @param jobCollectionId - Job collection ID
+ * @param options - Wait options
+ * @returns Final state of the workflow log tree
+ */
+export async function waitForWorkflowTree(jobCollectionId, options) {
+    const timeout = options?.timeout ?? 30000;
+    const pollInterval = options?.pollInterval ?? 2000;
+    const startTime = Date.now();
+    let lastTree = {
+        root: null,
+        logs: new Map(),
+        isComplete: false,
+        hasErrors: false,
+        leaves: [],
+        errors: [],
+        allChildrenDiscovered: false,
+    };
+    // Track stability: require the same log count for 2 consecutive polls
+    // before declaring complete. This handles async sent_to relationship updates.
+    let stableCount = 0;
+    let lastLogCount = 0;
+    while (Date.now() - startTime < timeout) {
+        try {
+            const tree = await buildWorkflowTree(jobCollectionId);
+            lastTree = tree;
+            // Call optional progress callback
+            if (options?.onPoll) {
+                options.onPoll(tree, Date.now() - startTime);
+            }
+            if (tree.isComplete) {
+                // Check if the tree is stable (same log count as last poll)
+                if (tree.logs.size === lastLogCount) {
+                    stableCount++;
+                    // Require 2 stable polls before returning (handles async relationship updates)
+                    if (stableCount >= 2) {
+                        return tree;
+                    }
+                }
+                else {
+                    // Log count changed, reset stability counter
+                    stableCount = 0;
+                }
+            }
+            else {
+                stableCount = 0;
+            }
+            lastLogCount = tree.logs.size;
+        }
+        catch {
+            // Ignore errors during polling, just retry
+            stableCount = 0;
+        }
+        await sleep(pollInterval);
+    }
+    // Timeout - return last known state
+    return lastTree;
+}
 //# sourceMappingURL=logs.js.map