@omni-oss/create-jobs 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 All notable changes to this project will be documented in this file. See [conventional commits](https://www.conventionalcommits.org/) for commit guidelines.
 
 - - -
+## @omni-oss/create-jobs-v0.1.7 - 2026-02-10
+#### Bug Fixes
+- generic publish task - (f5d56c4) - Clarence Manuel
+
+- - -
+
+## @omni-oss/create-jobs-v0.1.6 - 2026-02-09
+#### Bug Fixes
+- (**@omni-oss/create-jobs**) support create jobs via is_*_task meta data - (d95dbca) - Clarence Manuel
+
+- - -
+
 ## @omni-oss/create-jobs-v0.1.5 - 2026-02-09
 #### Bug Fixes
 - (**@omni-oss/create-jobs**) support sanitizing artifact names - (1ed9932) - Clarence Manuel

package/dist/create-jobs.cjs

@@ -1,2 +1,2 @@
 #!/usr/bin/env bun
-"use strict";const o=require("node:fs/promises"),i=require("@commander-js/extra-typings"),r=require("./schemas-BCY99Jil.js"),l=new i.Command;l.argument("<input>","The input file to read from.").option("-o, --output <output>","The output file to write to.").action(async(n,t)=>{const u=await o.readFile(n,"utf-8"),a=JSON.parse(u),e=r.TaskResultArraySchema.safeParse(a);if(e.success){const c=e.data,s=r.createJobs(c);t.output?await o.writeFile(t.output,JSON.stringify(s,null,2)):console.log(s)}else console.error(e.error),process.exit(1)}).parseAsync();
+"use strict";const r=require("node:fs/promises"),i=require("@commander-js/extra-typings"),s=require("./schemas-BnpD42eF.js"),l=new i.Command;l.argument("<input>","The input file to read from.").option("-o, --output <output>","The output file to write to.").option("-r, --root <root>","Override the workspace root.").action(async(n,e)=>{const a=await r.readFile(n,"utf-8"),u=JSON.parse(a),t=s.TaskResultArraySchema.safeParse(u);if(t.success){const c=t.data,o=s.createJobs(c,e.root);e.output?await r.writeFile(e.output,JSON.stringify(o,null,2)):console.log(o)}else console.error(t.error),process.exit(1)}).parseAsync();

package/dist/create-jobs.d.ts

@@ -29,7 +29,8 @@ export type BuildJobs = {
 };
 export type PublishJobs = {
     npm: Job[];
+    generic: Job[];
     rust_github: Job[];
 };
-export declare function createJobs(results: TaskResultArray): Jobs;
+export declare function createJobs(results: TaskResultArray, rootDir?: string): Jobs;
 //# sourceMappingURL=create-jobs.d.ts.map

package/dist/create-jobs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-jobs.d.ts","sourceRoot":"","sources":["../src/create-jobs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAc,eAAe,EAAE,MAAM,WAAW,CAAC;AAEnE,MAAM,MAAM,QAAQ,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,GAAG,GAAG;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE;QACP,SAAS,EAAE,QAAQ,CAAC;QACpB,OAAO,EAAE,QAAQ,CAAC;KACrB,CAAC;IACF,IAAI,EAAE,IAAI,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,WAAW,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACnB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,GAAG,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACpB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,GAAG,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACtB,GAAG,EAAE,GAAG,EAAE,CAAC;IACX,WAAW,EAAE,GAAG,EAAE,CAAC;CACtB,CAAC;AAEF,wBAAgB,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAuDzD"}
+{"version":3,"file":"create-jobs.d.ts","sourceRoot":"","sources":["../src/create-jobs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAc,eAAe,EAAE,MAAM,WAAW,CAAC;AAEnE,MAAM,MAAM,QAAQ,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,GAAG,GAAG;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE;QACP,SAAS,EAAE,QAAQ,CAAC;QACpB,OAAO,EAAE,QAAQ,CAAC;KACrB,CAAC;IACF,IAAI,EAAE,IAAI,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,WAAW,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACnB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,GAAG,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACpB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,GAAG,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACtB,GAAG,EAAE,GAAG,EAAE,CAAC;IACX,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,WAAW,EAAE,GAAG,EAAE,CAAC;CACtB,CAAC;AAEF,wBAAgB,UAAU,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CA8D3E"}

package/dist/create-jobs.mjs

@@ -1,16 +1,16 @@
 #!/usr/bin/env bun
-import s from "node:fs/promises";
+import r from "node:fs/promises";
 import { Command as u } from "@commander-js/extra-typings";
-import { T as c, c as l } from "./schemas-BNiWDmJf.mjs";
-const p = new u();
-p.argument("<input>", "The input file to read from.").option("-o, --output <output>", "The output file to write to.").action(async (r, e) => {
-  const a = await s.readFile(r, "utf-8"), n = JSON.parse(a), t = c.safeParse(n);
-  if (t.success) {
-    const i = t.data, o = l(i);
-    e.output ? await s.writeFile(
-      e.output,
-      JSON.stringify(o, null, 2)
-    ) : console.log(o);
+import { T as c, c as p } from "./schemas-CySsa0xy.mjs";
+const l = new u();
+l.argument("<input>", "The input file to read from.").option("-o, --output <output>", "The output file to write to.").option("-r, --root <root>", "Override the workspace root.").action(async (s, t) => {
+  const a = await r.readFile(s, "utf-8"), n = JSON.parse(a), o = c.safeParse(n);
+  if (o.success) {
+    const i = o.data, e = p(i, t.root);
+    t.output ? await r.writeFile(
+      t.output,
+      JSON.stringify(e, null, 2)
+    ) : console.log(e);
   } else
-    console.error(t.error), process.exit(1);
+    console.error(o.error), process.exit(1);
 }).parseAsync();

package/dist/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./schemas-BCY99Jil.js");exports.TaskResultArraySchema=e.TaskResultArraySchema;exports.TaskResultSchema=e.TaskResultSchema;exports.createJobs=e.createJobs;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./schemas-BnpD42eF.js");exports.TaskResultArraySchema=e.TaskResultArraySchema;exports.TaskResultSchema=e.TaskResultSchema;exports.createJobs=e.createJobs;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { T as e, a as r, c } from "./schemas-BNiWDmJf.mjs";
+import { T as e, a as r, c } from "./schemas-CySsa0xy.mjs";
 export {
   e as TaskResultArraySchema,
   r as TaskResultSchema,

package/dist/schemas-BnpD42eF.js

@@ -0,0 +1 @@
+"use strict";const n=require("node:path"),u=require("node:process"),e=require("zod");function b(s,a){a||(a=u.cwd());const i={test:{rust:[],typescript:[]},build:{rust:[],typescript:[]},publish:{generic:[],npm:[],rust_github:[]}};for(const t of s){if(t.status==="skipped")continue;const o=t.task;(o.task_name==="test"||t.details.meta?.is_test_task)&&(t.details.meta?.language==="rust"&&i.test.rust.push(r(t,a)),t.details.meta?.language==="typescript"&&i.test.typescript.push(r(t,a))),(o.task_name==="build"||t.details.meta?.is_build_task)&&(t.details.meta?.language==="rust"&&i.build.rust.push(r(t,a)),t.details.meta?.language==="typescript"&&i.build.typescript.push(r(t,a))),(o.task_name==="publish"||t.details.meta?.is_publish_task)&&(t.details.meta?.language==="typescript"?i.publish.npm.push(r(t,a)):t.details.meta?.language==="rust"?i.publish.rust_github.push(r(t,a)):i.publish.generic.push(r(t,a)))}return i}function r(s,a){const i=[],t=[];if(s.details.output_files&&s.details.output_files.length>0)for(const o of s.details.output_files){const l=n.resolve(s.task.project_dir,o);m(s.task.project_dir,l)?t.push(n.relative(s.task.project_dir,l)):i.push(n.relative(a,l))}return{task_name:s.task.task_name,project_name:s.task.project_name,artifacts:{project:{name:`project-${c(s.task.project_name)}__${c(s.task.task_name)}`,files:t,files_count:t.length},workspace:{name:`workspace-${c(s.task.project_name)}__${c(s.task.task_name)}`,files:i,files_count:i.length}},project_dir:n.relative(a,s.task.project_dir),meta:s.details.meta??{}}}function m(s,a){const i=n.relative(s,a);return i&&!i.startsWith("..")&&!n.isAbsolute(i)}function c(s){let a=s.replace(/[/\\?%*:|"<> \x00-\x1f]/g,"_");return a=a.replace(/[.\s]+$/,""),/^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i.test(a)&&(a+="_"),a||"unsaved_file"}const f=e.z.object({secs:e.z.number().int().nonnegative().describe("The number of whole seconds elapsed."),nanos:e.z.number().int().nonnegative().describe("The number of nanoseconds elapsed.")}),k=e.z.object({runner:e.z.string().describe("The runner to use for the target.")}),g=e.z.object({npm:e.z.boolean().optional().describe("Whether to publish to npm."),github:e.z.boolean().optional().describe("Whether to publish to github.")}),_=e.z.object({type:e.z.string().optional().describe("The type of project (e.g., library, service, application)."),language:e.z.string().optional().describe("The primary language of the project."),targets:e.z.record(e.z.string(),k).optional().describe("The targets to build."),release:g.optional(),is_publish_task:e.z.boolean().optional().describe("Whether this is a publish job."),is_build_task:e.z.boolean().optional().describe("Whether this is a build job."),is_test_task:e.z.boolean().optional().describe("Whether this is a test job.")}),p=e.z.object({meta:_.optional(),output_files:e.z.array(e.z.string()).optional().describe("The output files generated.")}),d=e.z.object({task_name:e.z.string().describe("The short name of the task (e.g., 'test', 'build')."),task_command:e.z.string().describe("The command executed for the task."),project_name:e.z.string().describe("The name of the project."),project_dir:e.z.string().describe("The absolute directory path of the project."),full_task_name:e.z.string().describe("The fully qualified task name (e.g., 'omni_utils#test')."),dependencies:e.z.array(e.z.string()).describe("A list of dependent task names."),enabled:e.z.boolean().or(e.z.string()).optional().describe("Whether the task is enabled by configuration. Either a boolean or a tera template string that evaluates to a boolean."),interactive:e.z.boolean().describe("Whether the task is interactive."),persistent:e.z.boolean().describe("Whether the task is persistent.")}),z=e.z.object({status:e.z.literal("completed"),hash:e.z.string().describe("The task's content hash (Base64 encoded string). Used for caching."),task:d,exit_code:e.z.number().int().describe("The exit code of the executed command (typically 0 for success)."),elapsed:f.describe("The duration the task took to execute."),cache_hit:e.z.boolean().describe("Indicates if the result was pulled from cache."),details:p}),j=e.z.object({status:e.z.literal("errored"),task:d,error:e.z.string().describe("The error message."),details:p}),T=e.z.object({status:e.z.literal("skipped"),task:d,skip_reason:e.z.string().describe("The reason the task was skipped (e.g., 'disabled')."),details:p}),h=e.z.discriminatedUnion("status",[z,T,j]).describe("Schema for a single task execution result (completed or skipped)."),y=e.z.array(h).describe("An array of task execution results.");exports.TaskResultArraySchema=y;exports.TaskResultSchema=h;exports.createJobs=b;

package/dist/{schemas-BNiWDmJf.mjs → schemas-CySsa0xy.mjs}

@@ -1,7 +1,9 @@
-import c from "node:path";
+import o from "node:path";
+import h from "node:process";
 import { z as e } from "zod";
-function y(s) {
-  const a = {
+function x(s, a) {
+  a || (a = h.cwd());
+  const i = {
     test: {
       rust: [],
       typescript: []
@@ -11,6 +13,7 @@ function y(s) {
       typescript: []
     },
     publish: {
+      generic: [],
       npm: [],
       rust_github: []
     }
@@ -18,62 +21,67 @@ function y(s) {
   for (const t of s) {
     if (t.status === "skipped")
       continue;
-    const r = t.task;
-    r.task_name === "test" && (t.details.meta?.language === "rust" && a.test.rust.push(i(t)), t.details.meta?.language === "typescript" && a.test.typescript.push(i(t))), r.task_name === "build" && (t.details.meta?.language === "rust" && a.build.rust.push(i(t)), t.details.meta?.language === "typescript" && a.build.typescript.push(i(t))), r.task_name === "publish" && t.details.meta?.release?.npm && a.publish.npm.push(i(t)), t.details.meta?.release?.github && t.details.meta?.language === "rust" && a.publish.rust_github.push(i(t));
+    const n = t.task;
+    (n.task_name === "test" || t.details.meta?.is_test_task) && (t.details.meta?.language === "rust" && i.test.rust.push(r(t, a)), t.details.meta?.language === "typescript" && i.test.typescript.push(r(t, a))), (n.task_name === "build" || t.details.meta?.is_build_task) && (t.details.meta?.language === "rust" && i.build.rust.push(r(t, a)), t.details.meta?.language === "typescript" && i.build.typescript.push(r(t, a))), (n.task_name === "publish" || t.details.meta?.is_publish_task) && (t.details.meta?.language === "typescript" ? i.publish.npm.push(r(t, a)) : t.details.meta?.language === "rust" ? i.publish.rust_github.push(r(t, a)) : i.publish.generic.push(r(t, a)));
   }
-  return a;
+  return i;
 }
-function i(s) {
-  const a = [], t = [];
+function r(s, a) {
+  const i = [], t = [];
   if (s.details.output_files && s.details.output_files.length > 0)
-    for (const r of s.details.output_files) {
-      const n = c.resolve(s.task.project_dir, r);
-      d(s.task.project_dir, n) ? t.push(n) : a.push(n);
+    for (const n of s.details.output_files) {
+      const l = o.resolve(s.task.project_dir, n);
+      u(s.task.project_dir, l) ? t.push(
+        o.relative(s.task.project_dir, l)
+      ) : i.push(o.relative(a, l));
     }
   return {
     task_name: s.task.task_name,
     project_name: s.task.project_name,
     artifacts: {
       project: {
-        name: `project-${o(s.task.project_name)}__${o(s.task.task_name)}`,
+        name: `project-${c(s.task.project_name)}__${c(s.task.task_name)}`,
         files: t,
         files_count: t.length
       },
       workspace: {
-        name: `workspace-${o(s.task.project_name)}__${o(s.task.task_name)}`,
-        files: a,
-        files_count: a.length
+        name: `workspace-${c(s.task.project_name)}__${c(s.task.task_name)}`,
+        files: i,
+        files_count: i.length
       }
     },
-    project_dir: s.task.project_dir,
+    project_dir: o.relative(a, s.task.project_dir),
     meta: s.details.meta ?? {}
   };
 }
-function d(s, a) {
-  const t = c.relative(s, a);
-  return t && !t.startsWith("..") && !c.isAbsolute(t);
+function u(s, a) {
+  const i = o.relative(s, a);
+  return i && !i.startsWith("..") && !o.isAbsolute(i);
 }
-function o(s) {
+function c(s) {
   let a = s.replace(/[/\\?%*:|"<> \x00-\x1f]/g, "_");
   return a = a.replace(/[.\s]+$/, ""), /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i.test(a) && (a += "_"), a || "unsaved_file";
 }
-const h = e.object({
+const b = e.object({
   secs: e.number().int().nonnegative().describe("The number of whole seconds elapsed."),
   nanos: e.number().int().nonnegative().describe("The number of nanoseconds elapsed.")
-}), u = e.object({
+}), m = e.object({
   runner: e.string().describe("The runner to use for the target.")
-}), b = e.object({
+}), f = e.object({
   npm: e.boolean().optional().describe("Whether to publish to npm."),
   github: e.boolean().optional().describe("Whether to publish to github.")
-}), m = e.object({
+}), g = e.object({
   type: e.string().optional().describe("The type of project (e.g., library, service, application)."),
   language: e.string().optional().describe("The primary language of the project."),
-  targets: e.record(e.string(), u).optional().describe("The targets to build."),
-  release: b.optional()
-}), l = e.object({
-  meta: m.optional(),
-  output_files: e.array(e.string()).optional().describe("The output files generated.")
+  targets: e.record(e.string(), m).optional().describe("The targets to build."),
+  release: f.optional(),
+  is_publish_task: e.boolean().optional().describe("Whether this is a publish job."),
+  is_build_task: e.boolean().optional().describe("Whether this is a build job."),
+  is_test_task: e.boolean().optional().describe("Whether this is a test job.")
 }), p = e.object({
+  meta: g.optional(),
+  output_files: e.array(e.string()).optional().describe("The output files generated.")
+}), d = e.object({
   task_name: e.string().describe("The short name of the task (e.g., 'test', 'build')."),
   task_command: e.string().describe("The command executed for the task."),
   project_name: e.string().describe("The name of the project."),
@@ -85,37 +93,37 @@ const h = e.object({
   ),
   interactive: e.boolean().describe("Whether the task is interactive."),
   persistent: e.boolean().describe("Whether the task is persistent.")
-}), f = e.object({
+}), k = e.object({
   status: e.literal("completed"),
   hash: e.string().describe(
     "The task's content hash (Base64 encoded string). Used for caching."
   ),
-  task: p,
+  task: d,
   exit_code: e.number().int().describe(
     "The exit code of the executed command (typically 0 for success)."
   ),
-  elapsed: h.describe("The duration the task took to execute."),
+  elapsed: b.describe("The duration the task took to execute."),
   cache_hit: e.boolean().describe("Indicates if the result was pulled from cache."),
-  details: l
-}), g = e.object({
+  details: p
+}), _ = e.object({
   status: e.literal("errored"),
-  task: p,
+  task: d,
   error: e.string().describe("The error message."),
-  details: l
-}), k = e.object({
+  details: p
+}), j = e.object({
   status: e.literal("skipped"),
-  task: p,
+  task: d,
   skip_reason: e.string().describe("The reason the task was skipped (e.g., 'disabled')."),
-  details: l
-}), _ = e.discriminatedUnion("status", [
-  f,
+  details: p
+}), T = e.discriminatedUnion("status", [
   k,
-  g
+  j,
+  _
 ]).describe(
   "Schema for a single task execution result (completed or skipped)."
-), S = e.array(_).describe("An array of task execution results.");
+), W = e.array(T).describe("An array of task execution results.");
 export {
-  S as T,
-  _ as a,
-  y as c
+  W as T,
+  T as a,
+  x as c
 };

package/dist/schemas.d.ts

@@ -19,6 +19,9 @@ declare const MetaSchema: z.ZodObject<{
         npm: z.ZodOptional<z.ZodBoolean>;
         github: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    is_publish_task: z.ZodOptional<z.ZodBoolean>;
+    is_build_task: z.ZodOptional<z.ZodBoolean>;
+    is_test_task: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 /**
  * Defines the details of the task that was run or skipped.
@@ -69,6 +72,9 @@ declare const CompletedTaskSchema: z.ZodObject<{
                 npm: z.ZodOptional<z.ZodBoolean>;
                 github: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
+            is_publish_task: z.ZodOptional<z.ZodBoolean>;
+            is_build_task: z.ZodOptional<z.ZodBoolean>;
+            is_test_task: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
@@ -102,6 +108,9 @@ declare const SkippedTaskSchema: z.ZodObject<{
                 npm: z.ZodOptional<z.ZodBoolean>;
                 github: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
+            is_publish_task: z.ZodOptional<z.ZodBoolean>;
+            is_build_task: z.ZodOptional<z.ZodBoolean>;
+            is_test_task: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
@@ -141,6 +150,9 @@ export declare const TaskResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 npm: z.ZodOptional<z.ZodBoolean>;
                 github: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
+            is_publish_task: z.ZodOptional<z.ZodBoolean>;
+            is_build_task: z.ZodOptional<z.ZodBoolean>;
+            is_test_task: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
@@ -169,6 +181,9 @@ export declare const TaskResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 npm: z.ZodOptional<z.ZodBoolean>;
                 github: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
+            is_publish_task: z.ZodOptional<z.ZodBoolean>;
+            is_build_task: z.ZodOptional<z.ZodBoolean>;
+            is_test_task: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
@@ -197,6 +212,9 @@ export declare const TaskResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 npm: z.ZodOptional<z.ZodBoolean>;
                 github: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
+            is_publish_task: z.ZodOptional<z.ZodBoolean>;
+            is_build_task: z.ZodOptional<z.ZodBoolean>;
+            is_test_task: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
@@ -235,6 +253,9 @@ export declare const TaskResultArraySchema: z.ZodArray<z.ZodDiscriminatedUnion<[
                 npm: z.ZodOptional<z.ZodBoolean>;
                 github: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
+            is_publish_task: z.ZodOptional<z.ZodBoolean>;
+            is_build_task: z.ZodOptional<z.ZodBoolean>;
+            is_test_task: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
@@ -263,6 +284,9 @@ export declare const TaskResultArraySchema: z.ZodArray<z.ZodDiscriminatedUnion<[
                 npm: z.ZodOptional<z.ZodBoolean>;
                 github: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
+            is_publish_task: z.ZodOptional<z.ZodBoolean>;
+            is_build_task: z.ZodOptional<z.ZodBoolean>;
+            is_test_task: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
@@ -291,6 +315,9 @@ export declare const TaskResultArraySchema: z.ZodArray<z.ZodDiscriminatedUnion<[
                 npm: z.ZodOptional<z.ZodBoolean>;
                 github: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
+            is_publish_task: z.ZodOptional<z.ZodBoolean>;
+            is_build_task: z.ZodOptional<z.ZodBoolean>;
+            is_test_task: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
         output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;

package/dist/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;GAEG;AACH,QAAA,MAAM,aAAa;;;iBAWjB,CAAC;AAWH;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;iBAcd,CAAC;AAUH;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;iBAwBd,CAAC;AAIH;;;GAGG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBvB,CAAC;AASH;;;GAGG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOrB,CAAC;AAIH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAQxB,CAAC;AAEN;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAEkB,CAAC;AAIrD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;GAEG;AACH,QAAA,MAAM,aAAa;;;iBAWjB,CAAC;AAWH;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;;;;iBA0Bd,CAAC;AAUH;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;iBAwBd,CAAC;AAIH;;;GAGG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBvB,CAAC;AASH;;;GAGG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOrB,CAAC;AAIH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAQxB,CAAC;AAEN;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAEkB,CAAC;AAIrD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@omni-oss/create-jobs",
-    "version": "0.1.5",
+    "version": "0.1.7",
     "bin": "./dist/create-jobs.mjs",
     "publishConfig": {
         "access": "public"

package/src/cli/index.ts

@@ -8,6 +8,7 @@ const command = new Command();
 command
     .argument("<input>", "The input file to read from.")
     .option("-o, --output <output>", "The output file to write to.")
+    .option("-r, --root <root>", "Override the workspace root.")
     .action(async (input, options) => {
         const inputFile = await fsAsync.readFile(input, "utf-8");
         const results = JSON.parse(inputFile);
@@ -15,7 +16,7 @@ command
 
         if (result.success) {
             const data = result.data;
-            const processed = createJobs(data);
+            const processed = createJobs(data, options.root);
             if (options.output) {
                 await fsAsync.writeFile(
                     options.output,

package/src/create-jobs.spec.ts

@@ -53,14 +53,14 @@ describe("createJobs", () => {
             },
         ];
 
-        const jobs = createJobs(results);
+        const jobs = createJobs(results, "/mnt/c/Users/user");
 
         expect(jobs.test.rust[0]).toMatchObject({
             project_name: "rust-app",
             task_name: "test",
             artifacts: {
                 project: {
-                    files: ["/mnt/c/Users/user/project/binary"],
+                    files: ["binary"],
                 },
             },
         });
@@ -77,12 +77,17 @@ describe("createJobs", () => {
                     project_name: "js-pkg",
                     project_dir: "/mnt/c/Users/user/project",
                 },
-                details: { meta: { release: { npm: true } } },
+                details: {
+                    meta: {
+                        language: "typescript",
+                        release: { npm: true },
+                    },
+                },
             },
             {
                 status: "success",
                 task: {
-                    task_name: "any-task",
+                    task_name: "publish",
                     project_name: "rust-pkg",
                     project_dir: "/mnt/c/Users/user/project",
                 },
@@ -101,8 +106,7 @@ describe("createJobs", () => {
         expect(jobs.publish.npm).toHaveLength(1);
         expect(jobs.publish.npm[0]?.project_name).toBe("js-pkg");
 
-        // Checks GitHub logic: meta.release.github must be true AND language must be "rust"
-        // Note: your code doesn't strictly check if task_name === "publish" for rust_github!
+        // Checks GitHub logic: meta.release.github must be true AND language must be "rust" AND task_name must be "publish"
         expect(jobs.publish.rust_github).toHaveLength(1);
         expect(jobs.publish.rust_github[0]?.project_name).toBe("rust-pkg");
     });
@@ -141,14 +145,14 @@ describe("createJobs", () => {
             },
         ];
 
-        const jobs = createJobs(results);
+        const jobs = createJobs(results, "/mnt/c/Users/usert");
 
         expect(jobs.test.rust[0]).toMatchObject({
             project_name: "minimal",
             task_name: "test",
             artifacts: {
                 project: {
-                    files: ["/mnt/c/Users/user/project/target/debug/minimal"],
+                    files: ["target/debug/minimal"],
                 },
             },
         });
@@ -170,14 +174,14 @@ describe("createJobs", () => {
             },
         ];
 
-        const jobs = createJobs(results);
+        const jobs = createJobs(results, "/mnt/c/Users/user");
 
         expect(jobs.test.rust[0]).toMatchObject({
             project_name: "minimal",
             task_name: "test",
             artifacts: {
                 workspace: {
-                    files: ["/mnt/c/Users/user/target/debug/minimal"],
+                    files: ["target/debug/minimal"],
                 },
             },
         });
@@ -216,4 +220,152 @@ describe("createJobs", () => {
             },
         });
     });
+
+    it("should handle is_publish_task correctly", () => {
+        const results: any[] = [
+            {
+                status: "success",
+                task: {
+                    task_name: "publish",
+                    project_name: "js-pkg",
+                    project_dir: "/mnt/c/Users/user/project",
+                },
+                details: {
+                    meta: {
+                        language: "typescript",
+                        release: { npm: true },
+                        is_publish_task: true,
+                    },
+                },
+            },
+            {
+                status: "success",
+                task: {
+                    task_name: "any-task",
+                    project_name: "rust-pkg",
+                    project_dir: "/mnt/c/Users/user/project",
+                },
+                details: {
+                    meta: {
+                        language: "rust",
+                        release: { github: true },
+                        is_publish_task: true,
+                    },
+                },
+            },
+        ];
+
+        const jobs = createJobs(results);
+
+        // Checks NPM logic: task_name must be "publish" AND meta.release.npm must be true
+        expect(jobs.publish.npm).toHaveLength(1);
+        expect(jobs.publish.npm[0]?.project_name).toBe("js-pkg");
+
+        // Checks GitHub logic: meta.release.github must be true AND language must be "rust"
+        // Note that your code doesn't strictly check if task_name === "publish" for rust_github!
+        expect(jobs.publish.rust_github).toHaveLength(1);
+        expect(jobs.publish.rust_github[0]?.project_name).toBe("rust-pkg");
+    });
+
+    it("should handle is_build_task correctly", () => {
+        const results: any[] = [
+            {
+                status: "success",
+                task: {
+                    task_name: "build",
+                    project_name: "ts-lib",
+                    project_dir: "/mnt/c/Users/user/project",
+                },
+                details: {
+                    meta: { language: "typescript", is_build_task: true },
+                },
+            },
+            {
+                status: "success",
+                task: {
+                    task_name: "any-task",
+                    project_name: "rust-pkg",
+                    project_dir: "/mnt/c/Users/user/project",
+                },
+                details: {
+                    meta: {
+                        language: "rust",
+                        is_build_task: true,
+                    },
+                },
+            },
+        ];
+
+        const jobs = createJobs(results);
+
+        // Checks build logic: task_name must be "build" AND meta.language must be "typescript"
+        expect(jobs.build.typescript).toHaveLength(1);
+        expect(jobs.build.typescript[0]?.project_name).toBe("ts-lib");
+
+        // Checks build logic: task_name must be "any-task" AND meta.language must be "rust"
+        expect(jobs.build.rust).toHaveLength(1);
+        expect(jobs.build.rust[0]?.project_name).toBe("rust-pkg");
+    });
+
+    it("should handle is_test_task correctly", () => {
+        const results: any[] = [
+            {
+                status: "success",
+                task: {
+                    task_name: "test",
+                    project_name: "rust-app",
+                    project_dir: "/mnt/c/Users/user/project",
+                },
+                details: {
+                    meta: { language: "rust", is_test_task: true },
+                },
+            },
+            {
+                status: "success",
+                task: {
+                    task_name: "test",
+                    project_name: "rust-pkg",
+                    project_dir: "/mnt/c/Users/user/project",
+                },
+                details: {
+                    meta: {
+                        language: "rust",
+                        is_test_task: true,
+                    },
+                },
+            },
+        ];
+
+        const jobs = createJobs(results);
+
+        // Checks test logic: task_name must be "test" AND meta.language must be "rust"
+        expect(jobs.test.rust).toHaveLength(2);
+        expect(jobs.test.rust[0]?.project_name).toBe("rust-app");
+        expect(jobs.test.rust[1]?.project_name).toBe("rust-pkg");
+    });
+
+    it("should handle generic publish tasks correctly", () => {
+        const results: any[] = [
+            {
+                status: "success",
+                task: {
+                    task_name: "publish",
+                    project_name: "rust-pkg",
+                    project_dir: "/mnt/c/Users/user/project",
+                },
+                details: {
+                    meta: {
+                        release: { github: true },
+                        is_publish_task: true,
+                    },
+                },
+            },
+        ];
+
+        const jobs = createJobs(results);
+
+        // Checks generic logic: task_name must be "publish" AND meta.release.github must be true
+        expect(jobs.publish.generic).toHaveLength(1);
+        expect(jobs.publish.generic[0]?.project_name).toBe("rust-pkg");
+    });
 });

package/src/create-jobs.ts

@@ -1,4 +1,5 @@
 import path from "node:path";
+import process from "node:process";
 import type { Meta, TaskResult, TaskResultArray } from "./schemas";
 
 export type Artifact = {
@@ -36,10 +37,15 @@ export type BuildJobs = {
 
 export type PublishJobs = {
     npm: Job[];
+    generic: Job[];
     rust_github: Job[];
 };
 
-export function createJobs(results: TaskResultArray): Jobs {
+export function createJobs(results: TaskResultArray, rootDir?: string): Jobs {
+    if (!rootDir) {
+        rootDir = process.cwd();
+    }
+
     const jobs: Jobs = {
         test: {
             rust: [],
@@ -50,6 +56,7 @@ export function createJobs(results: TaskResultArray): Jobs {
             typescript: [],
         },
         publish: {
+            generic: [],
             npm: [],
             rust_github: [],
         },
@@ -61,42 +68,44 @@ export function createJobs(results: TaskResultArray): Jobs {
         }
 
         const task = result.task;
-        if (task.task_name === "test") {
+        if (task.task_name === "test" || result.details.meta?.is_test_task) {
             if (result.details.meta?.language === "rust") {
-                jobs.test.rust.push(jobFromResult(result));
+                jobs.test.rust.push(jobFromResult(result, rootDir));
             }
 
             if (result.details.meta?.language === "typescript") {
-                jobs.test.typescript.push(jobFromResult(result));
+                jobs.test.typescript.push(jobFromResult(result, rootDir));
             }
         }
 
-        if (task.task_name === "build") {
+        if (task.task_name === "build" || result.details.meta?.is_build_task) {
             if (result.details.meta?.language === "rust") {
-                jobs.build.rust.push(jobFromResult(result));
+                jobs.build.rust.push(jobFromResult(result, rootDir));
             }
 
             if (result.details.meta?.language === "typescript") {
-                jobs.build.typescript.push(jobFromResult(result));
+                jobs.build.typescript.push(jobFromResult(result, rootDir));
             }
         }
 
-        if (task.task_name === "publish" && result.details.meta?.release?.npm) {
-            jobs.publish.npm.push(jobFromResult(result));
-        }
-
         if (
-            result.details.meta?.release?.github &&
-            result.details.meta?.language === "rust"
+            task.task_name === "publish" ||
+            result.details.meta?.is_publish_task
         ) {
-            jobs.publish.rust_github.push(jobFromResult(result));
+            if (result.details.meta?.language === "typescript") {
+                jobs.publish.npm.push(jobFromResult(result, rootDir));
+            } else if (result.details.meta?.language === "rust") {
+                jobs.publish.rust_github.push(jobFromResult(result, rootDir));
+            } else {
+                jobs.publish.generic.push(jobFromResult(result, rootDir));
+            }
         }
     }
 
     return jobs;
 }
 
-function jobFromResult(result: TaskResult): Job {
+function jobFromResult(result: TaskResult, rootDir: string): Job {
     const workspaceArtifacts = [] as string[];
     const projectArtifacts = [] as string[];
 
@@ -105,9 +114,11 @@ function jobFromResult(result: TaskResult): Job {
             const fullPath = path.resolve(result.task.project_dir, file);
 
             if (isPathInside(result.task.project_dir, fullPath)) {
-                projectArtifacts.push(fullPath);
+                projectArtifacts.push(
+                    path.relative(result.task.project_dir, fullPath),
+                );
             } else {
-                workspaceArtifacts.push(fullPath);
+                workspaceArtifacts.push(path.relative(rootDir, fullPath));
             }
         }
     }
@@ -127,7 +138,7 @@ function jobFromResult(result: TaskResult): Job {
                 files_count: workspaceArtifacts.length,
             },
         },
-        project_dir: result.task.project_dir,
+        project_dir: path.relative(rootDir, result.task.project_dir),
         meta: result.details.meta ?? {},
     };
 }

package/src/schemas.ts

@@ -44,6 +44,18 @@ const MetaSchema = z.object({
         .optional()
         .describe("The targets to build."),
     release: ReleaseSchema.optional(),
+    is_publish_task: z
+        .boolean()
+        .optional()
+        .describe("Whether this is a publish job."),
+    is_build_task: z
+        .boolean()
+        .optional()
+        .describe("Whether this is a build job."),
+    is_test_task: z
+        .boolean()
+        .optional()
+        .describe("Whether this is a test job."),
 });
 
 const DetailsSchema = z.object({

package/vite.config.ts

@@ -6,7 +6,12 @@ const baseConfig = createBaseConfig({
     generateTypes: true,
 });
 
-const externalNodeDeps = ["node:path", "node:fs", "node:fs/promises"];
+const externalNodeDeps = [
+    "node:path",
+    "node:fs",
+    "node:fs/promises",
+    "node:process",
+];
 
 export default mergeConfig(baseConfig, {
     build: {

package/dist/schemas-BCY99Jil.js

@@ -1 +0,0 @@
-"use strict";const c=require("node:path"),e=require("zod");function h(s){const a={test:{rust:[],typescript:[]},build:{rust:[],typescript:[]},publish:{npm:[],rust_github:[]}};for(const t of s){if(t.status==="skipped")continue;const r=t.task;r.task_name==="test"&&(t.details.meta?.language==="rust"&&a.test.rust.push(i(t)),t.details.meta?.language==="typescript"&&a.test.typescript.push(i(t))),r.task_name==="build"&&(t.details.meta?.language==="rust"&&a.build.rust.push(i(t)),t.details.meta?.language==="typescript"&&a.build.typescript.push(i(t))),r.task_name==="publish"&&t.details.meta?.release?.npm&&a.publish.npm.push(i(t)),t.details.meta?.release?.github&&t.details.meta?.language==="rust"&&a.publish.rust_github.push(i(t))}return a}function i(s){const a=[],t=[];if(s.details.output_files&&s.details.output_files.length>0)for(const r of s.details.output_files){const n=c.resolve(s.task.project_dir,r);u(s.task.project_dir,n)?t.push(n):a.push(n)}return{task_name:s.task.task_name,project_name:s.task.project_name,artifacts:{project:{name:`project-${o(s.task.project_name)}__${o(s.task.task_name)}`,files:t,files_count:t.length},workspace:{name:`workspace-${o(s.task.project_name)}__${o(s.task.task_name)}`,files:a,files_count:a.length}},project_dir:s.task.project_dir,meta:s.details.meta??{}}}function u(s,a){const t=c.relative(s,a);return t&&!t.startsWith("..")&&!c.isAbsolute(t)}function o(s){let a=s.replace(/[/\\?%*:|"<> \x00-\x1f]/g,"_");return a=a.replace(/[.\s]+$/,""),/^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i.test(a)&&(a+="_"),a||"unsaved_file"}const b=e.z.object({secs:e.z.number().int().nonnegative().describe("The number of whole seconds elapsed."),nanos:e.z.number().int().nonnegative().describe("The number of nanoseconds elapsed.")}),m=e.z.object({runner:e.z.string().describe("The runner to use for the target.")}),f=e.z.object({npm:e.z.boolean().optional().describe("Whether to publish to npm."),github:e.z.boolean().optional().describe("Whether to publish to github.")}),g=e.z.object({type:e.z.string().optional().describe("The type of project (e.g., library, service, application)."),language:e.z.string().optional().describe("The primary language of the project."),targets:e.z.record(e.z.string(),m).optional().describe("The targets to build."),release:f.optional()}),l=e.z.object({meta:g.optional(),output_files:e.z.array(e.z.string()).optional().describe("The output files generated.")}),d=e.z.object({task_name:e.z.string().describe("The short name of the task (e.g., 'test', 'build')."),task_command:e.z.string().describe("The command executed for the task."),project_name:e.z.string().describe("The name of the project."),project_dir:e.z.string().describe("The absolute directory path of the project."),full_task_name:e.z.string().describe("The fully qualified task name (e.g., 'omni_utils#test')."),dependencies:e.z.array(e.z.string()).describe("A list of dependent task names."),enabled:e.z.boolean().or(e.z.string()).optional().describe("Whether the task is enabled by configuration. Either a boolean or a tera template string that evaluates to a boolean."),interactive:e.z.boolean().describe("Whether the task is interactive."),persistent:e.z.boolean().describe("Whether the task is persistent.")}),k=e.z.object({status:e.z.literal("completed"),hash:e.z.string().describe("The task's content hash (Base64 encoded string). Used for caching."),task:d,exit_code:e.z.number().int().describe("The exit code of the executed command (typically 0 for success)."),elapsed:b.describe("The duration the task took to execute."),cache_hit:e.z.boolean().describe("Indicates if the result was pulled from cache."),details:l}),z=e.z.object({status:e.z.literal("errored"),task:d,error:e.z.string().describe("The error message."),details:l}),_=e.z.object({status:e.z.literal("skipped"),task:d,skip_reason:e.z.string().describe("The reason the task was skipped (e.g., 'disabled')."),details:l}),p=e.z.discriminatedUnion("status",[k,_,z]).describe("Schema for a single task execution result (completed or skipped)."),j=e.z.array(p).describe("An array of task execution results.");exports.TaskResultArraySchema=j;exports.TaskResultSchema=p;exports.createJobs=h;