@clipboard-health/groundcrew 4.29.0 → 4.30.0

package/dist/lib/adapters/shell/factory.d.ts

@@ -1,7 +1,7 @@
 /**
  * Shell-adapter `TaskSource` factory. Wires `invokeShellCommand` to the
- * four TaskSource operations and applies the ShellIssue Zod schema for
- * runtime validation of script stdout.
+ * TaskSource operations and applies the ShellIssue Zod schema for runtime
+ * validation of script stdout.
  *
  * Fallback behavior for omitted commands:
  *  - `verify` absent → no-op (always succeeds).
@@ -13,6 +13,10 @@
  *  - `markInProgress` absent → silent no-op.
  *  - `markInReview` absent → reports unsupported.
  *  - `markDone` absent → reports unsupported.
+ *  - `createTask` absent → method omitted entirely (source reports it cannot
+ *    create tasks; the optional method is attached only when configured).
+ *  - `validate` absent → method omitted entirely (same capability-detection
+ *    contract as createTask).
  *  - `fetch` is required by the Zod schema.
  */
 import type { AdapterContext } from "../../adapterDefinition.ts";

package/dist/lib/adapters/shell/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/lib/adapters/shell/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAGL,KAAK,KAAK,IAAI,cAAc,EAG5B,KAAK,UAAU,EAChB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,KAAK,kBAAkB,EAEvB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAkErB,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,CAuB3F;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,cAAc,GACvB,UAAU,CAyHZ"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/lib/adapters/shell/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAIL,KAAK,KAAK,IAAI,cAAc,EAG5B,KAAK,UAAU,EAChB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,KAAK,kBAAkB,EAEvB,KAAK,UAAU,EAGhB,MAAM,aAAa,CAAC;AAyErB,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,CAuB3F;AA8BD,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,cAAc,GACvB,UAAU,CA6LZ"}

package/dist/lib/adapters/shell/factory.js

@@ -1,7 +1,7 @@
 /**
  * Shell-adapter `TaskSource` factory. Wires `invokeShellCommand` to the
- * four TaskSource operations and applies the ShellIssue Zod schema for
- * runtime validation of script stdout.
+ * TaskSource operations and applies the ShellIssue Zod schema for runtime
+ * validation of script stdout.
  *
  * Fallback behavior for omitted commands:
  *  - `verify` absent → no-op (always succeeds).
@@ -13,12 +13,16 @@
  *  - `markInProgress` absent → silent no-op.
  *  - `markInReview` absent → reports unsupported.
  *  - `markDone` absent → reports unsupported.
+ *  - `createTask` absent → method omitted entirely (source reports it cannot
+ *    create tasks; the optional method is attached only when configured).
+ *  - `validate` absent → method omitted entirely (same capability-detection
+ *    contract as createTask).
  *  - `fetch` is required by the Zod schema.
  */
 import { toCanonicalId, } from "../../taskSource.js";
-import { writeError } from "../../util.js";
+import { errorMessage, writeError } from "../../util.js";
 import { invokeShellCommand } from "./invoke.js";
-import { shellFetchOutputSchema, shellIssueSchema, } from "./schema.js";
+import { shellFetchOutputSchema, shellIssueSchema, shellValidateOutputSchema, } from "./schema.js";
 const DEFAULT_TIMEOUTS = {
     verify: 10_000,
     listTasks: 30_000,
@@ -26,15 +30,20 @@ const DEFAULT_TIMEOUTS = {
     markInProgress: 10_000,
     markInReview: 10_000,
     markDone: 10_000,
+    createTask: 30_000,
+    validate: 30_000,
 };
 function mergeTimeouts(overrides) {
+    const o = overrides ?? {};
     return {
-        verify: overrides?.verify ?? DEFAULT_TIMEOUTS.verify,
-        listTasks: overrides?.listTasks ?? overrides?.fetch ?? DEFAULT_TIMEOUTS.listTasks,
-        getTask: overrides?.getTask ?? overrides?.resolveOne ?? DEFAULT_TIMEOUTS.getTask,
-        markInProgress: overrides?.markInProgress ?? DEFAULT_TIMEOUTS.markInProgress,
-        markInReview: overrides?.markInReview ?? DEFAULT_TIMEOUTS.markInReview,
-        markDone: overrides?.markDone ?? DEFAULT_TIMEOUTS.markDone,
+        verify: o.verify ?? DEFAULT_TIMEOUTS.verify,
+        listTasks: o.listTasks ?? o.fetch ?? DEFAULT_TIMEOUTS.listTasks,
+        getTask: o.getTask ?? o.resolveOne ?? DEFAULT_TIMEOUTS.getTask,
+        markInProgress: o.markInProgress ?? DEFAULT_TIMEOUTS.markInProgress,
+        markInReview: o.markInReview ?? DEFAULT_TIMEOUTS.markInReview,
+        markDone: o.markDone ?? DEFAULT_TIMEOUTS.markDone,
+        createTask: o.createTask ?? DEFAULT_TIMEOUTS.createTask,
+        validate: o.validate ?? DEFAULT_TIMEOUTS.validate,
     };
 }
 function warnDuplicate(sourceName, preferred, legacy) {
@@ -85,6 +94,33 @@ export function toCanonicalIssue(shellIssue, sourceName) {
         sourceRef: shellIssue.sourceRef,
     };
 }
+/**
+ * Flatten a CreateTaskInput into the `${...}` substitution map the createTask
+ * script receives. Every key is always present — absent optionals become an
+ * empty string — so no placeholder is ever left literally in the command.
+ * List fields are comma-joined into a single value.
+ */
+function createTaskSubstitutions(input) {
+    return {
+        title: input.title,
+        agent: input.agent,
+        // Exposed under both `repo` (short form) and `repository` (matches the
+        // CreateTaskInput field name) so either placeholder resolves.
+        repo: input.repository ?? "",
+        repository: input.repository ?? "",
+        team: input.team ?? "",
+        id: input.id ?? "",
+        priority: input.priority ?? "",
+        due: input.due ?? "",
+        recurrence: input.recurrence ?? "",
+        promptFile: input.promptFile ?? "",
+        description: input.description ?? "",
+        edit: input.edit ? "true" : "",
+        projects: input.projects.join(","),
+        contexts: input.contexts.join(","),
+        dependencies: input.dependencies.join(","),
+    };
+}
 export function createShellTaskSource(config, _context) {
     const sourceName = config.name;
     const timeouts = mergeTimeouts(config.timeouts);
@@ -149,7 +185,7 @@ export function createShellTaskSource(config, _context) {
             sourceName,
         });
     }
-    return {
+    const source = {
         name: sourceName,
         async verify() {
             const verifyCommand = config.commands.verify;
@@ -198,4 +234,66 @@ export function createShellTaskSource(config, _context) {
             return { outcome: "applied" };
         },
     };
+    // createTask / validate are attached only when their command is configured.
+    // Capability detection keys off `source.createTask === undefined` /
+    // `source.validate === undefined`, so a slot left unset must leave the
+    // method genuinely absent rather than present-but-failing.
+    const createTaskCommand = config.commands.createTask;
+    if (createTaskCommand !== undefined) {
+        source.createTask = async (input) => {
+            const { stdout, exitCode } = await invokeShellCommand({
+                command: createTaskCommand,
+                timeoutMs: timeouts.createTask,
+                cwd: config.cwd,
+                env: config.env,
+                substitutions: createTaskSubstitutions(input),
+                sourceName,
+            });
+            // invokeShellCommand resolves (does not throw) on exit 3 — its "not
+            // found" sentinel for lookups. Creation has no not-found concept, so any
+            // nonzero exit is a failure: surface it rather than parse partial output.
+            if (exitCode === 3) {
+                throw new Error(`shell source "${sourceName}" createTask command exited 3 (not-found); task creation cannot signal not-found`);
+            }
+            const trimmed = stdout.trim();
+            if (trimmed.length === 0) {
+                throw new Error(`shell source "${sourceName}" createTask command produced no output (expected one ShellIssue JSON)`);
+            }
+            const parsed = shellIssueSchema.parse(JSON.parse(trimmed));
+            return toCanonicalIssue(parsed, sourceName);
+        };
+    }
+    const validateCommand = config.commands.validate;
+    if (validateCommand !== undefined) {
+        source.validate = async () => {
+            try {
+                const { stdout, exitCode } = await invokeShellCommand({
+                    command: validateCommand,
+                    timeoutMs: timeouts.validate,
+                    cwd: config.cwd,
+                    env: config.env,
+                    sourceName,
+                });
+                // exit 3 is invoke's lookup "not found" sentinel; for validation it is
+                // not a meaningful success, so surface it as a failure (and validate
+                // never throws — return the failure as an error string).
+                if (exitCode === 3) {
+                    return [
+                        `shell source "${sourceName}" validate command exited 3 (not-found); treating as a validation failure`,
+                    ];
+                }
+                const trimmed = stdout.trim();
+                if (trimmed.length === 0) {
+                    return [];
+                }
+                return shellValidateOutputSchema.parse(JSON.parse(trimmed));
+            }
+            catch (error) {
+                // Contract: validate() never throws — fold a nonzero exit, timeout,
+                // malformed JSON, or wrong-shape payload into a single error string.
+                return [`shell source "${sourceName}" validate command failed: ${errorMessage(error)}`];
+            }
+        };
+    }
+    return source;
 }

package/dist/lib/adapters/shell/schema.d.ts

@@ -80,6 +80,12 @@ export declare const shellFetchOutputSchema: z.ZodArray<z.ZodObject<{
     url: z.ZodOptional<z.ZodURL>;
     sourceRef: z.ZodUnknown;
 }, z.core.$strip>>;
+/**
+ * Shape a `commands.validate` script must emit on stdout: a JSON array of
+ * human-readable error strings. An empty array (or empty stdout, handled by
+ * the factory) means "no problems found".
+ */
+export declare const shellValidateOutputSchema: z.ZodArray<z.ZodString>;
 export declare const shellAdapterConfigSchema: z.ZodObject<{
     kind: z.ZodLiteral<"shell">;
     name: z.ZodString;
@@ -92,6 +98,8 @@ export declare const shellAdapterConfigSchema: z.ZodObject<{
         markInProgress: z.ZodOptional<z.ZodString>;
         markInReview: z.ZodOptional<z.ZodString>;
         markDone: z.ZodOptional<z.ZodString>;
+        createTask: z.ZodOptional<z.ZodString>;
+        validate: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     cwd: z.ZodOptional<z.ZodString>;
     timeouts: z.ZodOptional<z.ZodObject<{
@@ -103,6 +111,8 @@ export declare const shellAdapterConfigSchema: z.ZodObject<{
         markInProgress: z.ZodOptional<z.ZodNumber>;
         markInReview: z.ZodOptional<z.ZodNumber>;
         markDone: z.ZodOptional<z.ZodNumber>;
+        createTask: z.ZodOptional<z.ZodNumber>;
+        validate: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;

package/dist/lib/adapters/shell/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/lib/adapters/shell/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiB3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA4B,CAAC;AAEhE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/lib/adapters/shell/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiB3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA4B,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,yBAAsB,CAAC;AAE7D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkEnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/lib/adapters/shell/schema.js

@@ -36,6 +36,12 @@ export const shellIssueSchema = z.object({
     sourceRef: z.unknown(),
 });
 export const shellFetchOutputSchema = z.array(shellIssueSchema);
+/**
+ * Shape a `commands.validate` script must emit on stdout: a JSON array of
+ * human-readable error strings. An empty array (or empty stdout, handled by
+ * the factory) means "no problems found".
+ */
+export const shellValidateOutputSchema = z.array(z.string());
 export const shellAdapterConfigSchema = z.object({
     kind: z.literal("shell"),
     name: z
@@ -55,6 +61,19 @@ export const shellAdapterConfigSchema = z.object({
         markInProgress: z.string().optional(),
         markInReview: z.string().optional(),
         markDone: z.string().optional(),
+        /**
+         * Create a task from a `CreateTaskInput`. Receives the input fields as
+         * shell-quoted `${...}` placeholders (see factory) and must print one
+         * ShellIssue JSON on stdout. Omitting it leaves the source unable to
+         * create tasks.
+         */
+        createTask: z.string().optional(),
+        /**
+         * Validate task content. Must print a JSON array of error strings on
+         * stdout (empty array / empty stdout = no problems). Omitting it leaves
+         * the source unable to validate.
+         */
+        validate: z.string().optional(),
     })
         .superRefine((commands, ctx) => {
         if (commands.listTasks === undefined && commands.fetch === undefined) {
@@ -82,6 +101,10 @@ export const shellAdapterConfigSchema = z.object({
         markInProgress: z.number().int().positive().optional(),
         markInReview: z.number().int().positive().optional(),
         markDone: z.number().int().positive().optional(),
+        /** Timeout for the createTask command. */
+        createTask: z.number().int().positive().optional(),
+        /** Timeout for the validate command. */
+        validate: z.number().int().positive().optional(),
     })
         .optional(),
     env: z.record(z.string(), z.string()).optional(),

package/dist/lib/sourceCapabilities.js

@@ -29,11 +29,11 @@ function shellCapabilities(raw) {
         verify: commands.verify !== undefined,
         listTasks: true,
         getTask: true,
-        createTask: false,
+        createTask: commands.createTask !== undefined,
         markInProgress: commands.markInProgress !== undefined,
         markInReview: commands.markInReview !== undefined,
         markDone: commands.markDone !== undefined,
-        validate: false,
+        validate: commands.validate !== undefined,
     };
 }
 const TODO_TXT_CAPABILITIES = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clipboard-health/groundcrew",
-  "version": "4.29.0",
+  "version": "4.30.0",
   "description": "Linear-driven orchestrator that launches AI coding agents in git worktrees, with workspace lifecycle and usage tracking.",
   "keywords": [
     "agent",