@clipboard-health/groundcrew 4.2.0 → 4.2.2

package/dist/lib/{linearIssueStatus.js → adapters/linear/writeback.js}

@@ -1,12 +1,18 @@
-import { log } from "./util.js";
+import { log } from "../../util.js";
 export function createLinearIssueStatusUpdater(arguments_) {
     const { client } = arguments_;
-    // The first matching workflow state per team is cached by teamId so the
-    // status writeback doesn't re-query Linear on every dispatch. Teams that
-    // genuinely lack an `started` workflow state stay in the negative cache
-    // until the dispatcher resets it at the top of each tick.
+    // Positive cache only. Keyed by teamId because the workflow `state.type ===
+    // "started"` lookup yields a single stateId per team — independent of which
+    // project the ticket belongs to. State ids don't change for misconfig
+    // reasons, so caching successful resolutions is safe across the process.
+    //
+    // No negative cache: a missing "started" workflow state is a Linear-side
+    // config issue the operator can correct mid-session, and a negative cache
+    // would mask that recovery until process restart. Slot count caps
+    // markInProgress calls per tick at 1-5, so re-fetching team states on
+    // every failing attempt costs at most a handful of extra Linear API calls
+    // per tick.
     const inProgressStateByTeam = new Map();
-    let teamsMissingInProgress = new Set();
     async function getInProgressStateId(teamId) {
         if (teamId.length === 0) {
             return undefined;
@@ -15,17 +21,13 @@ export function createLinearIssueStatusUpdater(arguments_) {
         if (cached !== undefined) {
             return cached;
         }
-        if (teamsMissingInProgress.has(teamId)) {
-            return undefined;
-        }
         const team = await client.team(teamId);
         const states = await team.states();
-        // Use the workflow state's *type* — Linear standardises on
-        // `started` for in-progress columns regardless of how the user renames
-        // them, so this works without any per-team status-name configuration.
+        // Use the workflow state's `type` — Linear standardises on `started` for
+        // in-progress columns regardless of how the user renames them, so this
+        // works without any per-team status-name configuration.
         const inProgress = states.nodes.find((state) => state.type === "started");
         if (inProgress?.id === undefined) {
-            teamsMissingInProgress.add(teamId);
             return undefined;
         }
         inProgressStateByTeam.set(teamId, inProgress.id);
@@ -39,8 +41,5 @@ export function createLinearIssueStatusUpdater(arguments_) {
         await client.updateIssue(issue.uuid, { stateId });
         log(`Marked ${issue.id} as in progress`);
     }
-    function resetMissingInProgressCache() {
-        teamsMissingInProgress = new Set();
-    }
-    return { markInProgress, resetMissingInProgressCache };
+    return { markInProgress };
 }

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

@@ -14,7 +14,7 @@
  *  - `fetch` is required by the Zod schema.
  */
 import type { AdapterContext } from "../../adapterDefinition.ts";
-import type { Issue as CanonicalIssue, TicketSource } from "../../ticketSource.ts";
+import { type Issue as CanonicalIssue, type TicketSource } from "../../ticketSource.ts";
 import { type ShellAdapterConfig, type ShellIssue } from "./schema.ts";
 export declare function toCanonicalIssue(shellIssue: ShellIssue, sourceName: string): CanonicalIssue;
 export declare function createShellTicketSource(config: ShellAdapterConfig, _context: AdapterContext): TicketSource;

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;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAEV,KAAK,IAAI,cAAc,EACvB,YAAY,EACb,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,KAAK,kBAAkB,EAEvB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAyBrB,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,CAoB3F;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,cAAc,GACvB,YAAY,CA+Ed"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/lib/adapters/shell/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAGL,KAAK,KAAK,IAAI,cAAc,EAC5B,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,KAAK,kBAAkB,EAEvB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAyBrB,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,CAsB3F;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,cAAc,GACvB,YAAY,CAgFd"}

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

@@ -13,6 +13,7 @@
  *  - `markInProgress` absent → silent no-op.
  *  - `fetch` is required by the Zod schema.
  */
+import { toCanonicalId, } from "../../ticketSource.js";
 import { invokeShellCommand } from "./invoke.js";
 import { shellFetchOutputSchema, shellIssueSchema, } from "./schema.js";
 const DEFAULT_TIMEOUTS = {
@@ -31,12 +32,14 @@ function mergeTimeouts(overrides) {
 }
 export function toCanonicalIssue(shellIssue, sourceName) {
     const blockers = shellIssue.blockers.map((b) => ({
-        id: `${sourceName}:${b.id}`,
+        id: toCanonicalId(sourceName, b.id),
         title: b.title,
         status: b.status,
+        ...(b.statusReason !== undefined && { statusReason: b.statusReason }),
+        ...(b.nativeStatus !== undefined && { nativeStatus: b.nativeStatus }),
     }));
     return {
-        id: `${sourceName}:${shellIssue.id}`,
+        id: toCanonicalId(sourceName, shellIssue.id),
         source: sourceName,
         title: shellIssue.title,
         description: shellIssue.description,
@@ -81,10 +84,11 @@ export function createShellTicketSource(config, _context) {
         },
         fetch: runFetch,
         async resolveOne(naturalId) {
+            const canonicalId = toCanonicalId(sourceName, naturalId);
             const resolveCommand = config.commands.resolveOne;
             if (resolveCommand === undefined) {
                 const all = await runFetch();
-                return all.find((i) => i.id === `${sourceName}:${naturalId}`);
+                return all.find((i) => i.id === canonicalId);
             }
             const result = await invokeShellCommand({
                 command: resolveCommand,
@@ -93,7 +97,7 @@ export function createShellTicketSource(config, _context) {
                 env: config.env,
                 substitutions: {
                     id: naturalId,
-                    canonicalId: `${sourceName}:${naturalId}`,
+                    canonicalId,
                     name: sourceName,
                 },
                 sourceName,

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

@@ -11,19 +11,12 @@
  * Exit code 0 = success; exit code 3 = "not found" (caller decides how to
  * interpret); any other nonzero exit throws.
  */
-export declare const SHELL_COMMAND_MAX_BUFFER_BYTES: number;
 export declare class ShellAdapterTimeoutError extends Error {
     constructor(arguments_: {
         command: string;
         timeoutMs: number;
     });
 }
-export declare class ShellAdapterOutputLimitError extends Error {
-    constructor(arguments_: {
-        command: string;
-        maxBytes: number;
-    });
-}
 interface InvokeArgs {
     command: string;
     timeoutMs: number;
@@ -33,11 +26,15 @@ interface InvokeArgs {
     substitutions?: Record<string, string> | undefined;
     /** Source name for log prefixing. */
     sourceName: string;
+    /** Override the default per-stream stdout/stderr cap (10 MB). Used by tests. */
+    maxOutputBytes?: number;
 }
 interface InvokeResult {
     stdout: string;
     stderr: string;
     exitCode: number;
+    /** True if either stream hit the byte cap and the rest was discarded. */
+    truncated: boolean;
 }
 export declare function applySubstitutions(command: string, subs: Record<string, string>): string;
 export declare function invokeShellCommand(args: InvokeArgs): Promise<InvokeResult>;

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

@@ -1 +1 @@
-{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../../../src/lib/adapters/shell/invoke.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,eAAO,MAAM,8BAA8B,QAAmB,CAAC;AAG/D,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,YAAmB,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAGpE;CACF;AAED,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,YAAmB,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAKnE;CACF;AAED,UAAU,UAAU;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACnD,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAmBD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAMxF;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CA8HhF"}
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../../../src/lib/adapters/shell/invoke.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAcH,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,YAAmB,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAGpE;CACF;AAED,UAAU,UAAU;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACnD,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,SAAS,EAAE,OAAO,CAAC;CACpB;AAMD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAMxF;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CAkGhF"}

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

@@ -13,31 +13,22 @@
  */
 import { spawn } from "node:child_process";
 import { log } from "../../util.js";
-export const SHELL_COMMAND_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
-const TIMEOUT_SIGNAL = "SIGKILL";
+/**
+ * Hard cap on captured stdout/stderr per stream. Misbehaving scripts that
+ * `yes | head -c <huge>` would otherwise exhaust memory. 10 MB is enough for
+ * any realistic JSON ticket payload; tests can override via InvokeArgs.maxOutputBytes
+ * to exercise the truncation path with a smaller fixture.
+ */
+const DEFAULT_MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
 export class ShellAdapterTimeoutError extends Error {
     constructor(arguments_) {
         super(`Shell command timed out after ${arguments_.timeoutMs}ms: ${arguments_.command}`);
         this.name = "ShellAdapterTimeoutError";
     }
 }
-export class ShellAdapterOutputLimitError extends Error {
-    constructor(arguments_) {
-        super(`Shell command exceeded combined stdout/stderr maxBuffer of ${arguments_.maxBytes} bytes: ${arguments_.command}`);
-        this.name = "ShellAdapterOutputLimitError";
-    }
-}
 function shellQuote(value) {
     return `'${value.replaceAll("'", String.raw `'\''`)}'`;
 }
-function killChildProcess(child, signal, shouldUseProcessGroup) {
-    /* v8 ignore next 4 @preserve -- fallback path is for Windows or a spawn failure before pid assignment */
-    if (!shouldUseProcessGroup || child.pid === undefined) {
-        child.kill(signal);
-        return;
-    }
-    process.kill(-child.pid, signal);
-}
 export function applySubstitutions(command, subs) {
     let result = command;
     for (const [key, value] of Object.entries(subs)) {
@@ -49,92 +40,72 @@ export async function invokeShellCommand(args) {
     const command = args.substitutions === undefined
         ? args.command
         : applySubstitutions(args.command, args.substitutions);
+    const maxBytes = args.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
     return await new Promise((resolve, reject) => {
-        const shouldUseProcessGroup = process.platform !== "win32";
         const child = spawn("sh", ["-c", command], {
             cwd: args.cwd,
-            detached: shouldUseProcessGroup,
             // oxlint-disable-next-line node/no-process-env -- subprocess inherits the parent's full env by design; user-supplied vars layer on top
             env: { ...process.env, ...args.env },
             stdio: ["pipe", "pipe", "pipe"],
         });
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        let stdoutLength = 0;
-        let stderrLength = 0;
+        let stdout = Buffer.alloc(0);
+        let stderr = Buffer.alloc(0);
+        let truncated = false;
         let settled = false;
-        function cleanup() {
-            clearTimeout(timer);
-        }
-        function killChild(signal) {
-            try {
-                killChildProcess(child, signal, shouldUseProcessGroup);
-            }
-            catch {
-                // The child may have exited between timeout/output-limit handling and the kill request.
-            }
-        }
-        function failAndKill(error) {
-            /* v8 ignore next 3 @preserve -- timeout/output-limit races can call this after another terminal event; deterministic tests cover the first terminal path */
+        const timer = setTimeout(() => {
+            /* v8 ignore next 3 @preserve -- timer/close race: clearTimeout in the close handler should prevent this branch, but the guard is kept as defense-in-depth */
             if (settled) {
                 return;
             }
             settled = true;
-            cleanup();
-            killChild(TIMEOUT_SIGNAL);
-            reject(error);
-        }
-        function appendOutput(input) {
-            /* v8 ignore next 3 @preserve -- streams may emit after timeout/output-limit settlement; this race guard is intentionally defensive */
-            if (settled) {
-                return input.currentLength;
+            child.kill("SIGKILL");
+            reject(new ShellAdapterTimeoutError({ command, timeoutMs: args.timeoutMs }));
+        }, args.timeoutMs);
+        // Buffer accumulators so the byte cap matches its name. A string-based
+        // comparison would measure UTF-16 code units against a byte budget,
+        // letting multibyte UTF-8 sneak past the cap and risking a mid-
+        // surrogate-pair slice on truncation.
+        const appendCapped = (current, chunk) => {
+            if (current.byteLength >= maxBytes) {
+                truncated = true;
+                return current;
             }
-            const nextCombinedLength = stdoutLength + stderrLength + input.chunk.length;
-            if (nextCombinedLength > SHELL_COMMAND_MAX_BUFFER_BYTES) {
-                failAndKill(new ShellAdapterOutputLimitError({
-                    command,
-                    maxBytes: SHELL_COMMAND_MAX_BUFFER_BYTES,
-                }));
-                return input.currentLength;
+            const next = Buffer.concat([current, chunk]);
+            if (next.byteLength <= maxBytes) {
+                return next;
             }
-            input.chunks.push(input.chunk);
-            return input.currentLength + input.chunk.length;
-        }
-        const timer = setTimeout(() => {
-            failAndKill(new ShellAdapterTimeoutError({ command, timeoutMs: args.timeoutMs }));
-        }, args.timeoutMs);
+            truncated = true;
+            const clipped = next.subarray(0, maxBytes);
+            return Buffer.concat([
+                clipped,
+                Buffer.from(`\n[truncated: stream exceeded ${maxBytes} bytes]`),
+            ]);
+        };
         child.stdout.on("data", (chunk) => {
-            stdoutLength = appendOutput({
-                chunks: stdoutChunks,
-                currentLength: stdoutLength,
-                chunk,
-            });
+            stdout = appendCapped(stdout, chunk);
         });
         child.stderr.on("data", (chunk) => {
-            stderrLength = appendOutput({
-                chunks: stderrChunks,
-                currentLength: stderrLength,
-                chunk,
-            });
+            stderr = appendCapped(stderr, chunk);
         });
         child.on("close", (code) => {
+            /* v8 ignore next 3 @preserve -- timer/close race: when the timeout fires first it SIGKILLs and sets settled=true; the 'close' event still arrives and must no-op. No deterministic test exists — an orphaned grandchild (`sh -c "sleep N; ..."`) keeps the stdout pipe open, so 'close' doesn't arrive until the real timeout elapses; mirrors the ignored timer/error settle guards above. */
             if (settled) {
                 return;
             }
             settled = true;
-            cleanup();
-            const stdout = Buffer.concat(stdoutChunks, stdoutLength).toString("utf8");
-            const stderr = Buffer.concat(stderrChunks, stderrLength).toString("utf8");
-            if (stderr.length > 0) {
-                log(`[shell:${args.sourceName}] ${command}\n${stderr.trimEnd()}`);
+            clearTimeout(timer);
+            const stderrText = stderr.toString("utf8");
+            if (stderrText.length > 0) {
+                log(`[shell:${args.sourceName}] ${command}\n${stderrText.trimEnd()}`);
             }
-            /* v8 ignore next @preserve -- `code` is null only when the process was killed by signal; timeout/output-limit paths settle before 'close' */
+            /* v8 ignore next @preserve -- `code` is null only when the process was killed by signal; the timeout path SIGKILLs but settles via the timer rather than 'close' */
             const exitCode = code ?? 1;
+            const stdoutText = stdout.toString("utf8");
             if (exitCode === 0 || exitCode === 3) {
-                resolve({ stdout, stderr, exitCode });
+                resolve({ stdout: stdoutText, stderr: stderrText, exitCode, truncated });
                 return;
             }
-            reject(new Error(`Shell command for source "${args.sourceName}" failed with exit ${exitCode}: ${stderr.trim().length > 0 ? stderr.trim() : command}`));
+            reject(new Error(`Shell command for source "${args.sourceName}" failed with exit ${exitCode}: ${stderrText.trim().length > 0 ? stderrText.trim() : command}`));
         });
         /* v8 ignore next 8 @preserve -- spawn 'error' event fires only on exec failures (PATH miss, EACCES) which are hard to simulate in tests without polluting host PATH */
         child.on("error", (error) => {
@@ -142,7 +113,7 @@ export async function invokeShellCommand(args) {
                 return;
             }
             settled = true;
-            cleanup();
+            clearTimeout(timer);
             reject(error);
         });
         if (args.stdin !== undefined) {

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

@@ -34,6 +34,11 @@ export declare const shellIssueSchema: z.ZodObject<{
             other: "other";
             todo: "todo";
         }>;
+        statusReason: z.ZodOptional<z.ZodEnum<{
+            missing: "missing";
+            unmapped: "unmapped";
+        }>>;
+        nativeStatus: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     hasMoreBlockers: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     sourceRef: z.ZodUnknown;
@@ -64,6 +69,11 @@ export declare const shellFetchOutputSchema: z.ZodArray<z.ZodObject<{
             other: "other";
             todo: "todo";
         }>;
+        statusReason: z.ZodOptional<z.ZodEnum<{
+            missing: "missing";
+            unmapped: "unmapped";
+        }>>;
+        nativeStatus: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     hasMoreBlockers: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     sourceRef: z.ZodUnknown;

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;AAWxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA4B,CAAC;AAEhE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;iBAqBnC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA4B,CAAC;AAEhE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;iBAwBnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

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

@@ -10,11 +10,12 @@
  */
 import { z } from "zod";
 const canonicalStatusSchema = z.enum(["todo", "in-progress", "in-review", "done", "other"]);
-const timeoutSchema = z.number().int().positive();
 const shellBlockerSchema = z.object({
     id: z.string(),
     title: z.string(),
     status: canonicalStatusSchema,
+    statusReason: z.enum(["missing", "unmapped"]).optional(),
+    nativeStatus: z.string().optional(),
 });
 export const shellIssueSchema = z.object({
     id: z.string(),
@@ -44,10 +45,13 @@ export const shellAdapterConfigSchema = z.object({
     cwd: z.string().optional(),
     timeouts: z
         .object({
-        verify: timeoutSchema.optional(),
-        fetch: timeoutSchema.optional(),
-        resolveOne: timeoutSchema.optional(),
-        markInProgress: timeoutSchema.optional(),
+        // Per-method timeout in milliseconds. Must be a positive integer —
+        // zero, negative, and fractional values would either deadlock or
+        // misbehave inside setTimeout.
+        verify: z.number().int().positive().optional(),
+        fetch: z.number().int().positive().optional(),
+        resolveOne: z.number().int().positive().optional(),
+        markInProgress: z.number().int().positive().optional(),
     })
         .optional(),
     env: z.record(z.string(), z.string()).optional(),

package/dist/lib/board.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"board.d.ts","sourceRoot":"","sources":["../../src/lib/board.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,KAAK;IACpB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAC7B;;;OAGG;IACH,UAAU,CAAC,oBAAoB,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IACrE,wFAAwF;IACxF,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7C;AAcD,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,KAAK,CAqEnE"}
+{"version":3,"file":"board.d.ts","sourceRoot":"","sources":["../../src/lib/board.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,KAAK,EAEV,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,KAAK;IACpB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAC7B;;;OAGG;IACH,UAAU,CAAC,oBAAoB,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IACrE,wFAAwF;IACxF,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7C;AAqBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,KAAK,CAwGnE"}

package/dist/lib/board.js

@@ -11,6 +11,12 @@ async function callVerify(source) {
 async function callFetch(source) {
     return await source.fetch();
 }
+async function callFetchParentSkips(source) {
+    if (source.fetchParentSkips !== undefined) {
+        return await source.fetchParentSkips();
+    }
+    return [];
+}
 async function callResolveOne(source, naturalId) {
     return await source.resolveOne(naturalId);
 }
@@ -38,8 +44,21 @@ export function createBoard(sources) {
             }
         },
         async fetch() {
-            const issuesPerSource = await Promise.all(sources.map(callFetch));
-            return { timestamp: new Date().toISOString(), issues: issuesPerSource.flat() };
+            // Per-source serialization: each source's callFetch must complete
+            // before its callFetchParentSkips so adapters that cache parent skips
+            // as a side effect of fetch() (e.g. Linear, which stores them on
+            // `lastParentSkips`) don't serve stale or empty data. Outer Promise.all
+            // keeps cross-source fan-out concurrent.
+            const perSource = await Promise.all(sources.map(async (source) => {
+                const issues = await callFetch(source);
+                const parentSkips = await callFetchParentSkips(source);
+                return { issues, parentSkips };
+            }));
+            return {
+                timestamp: new Date().toISOString(),
+                issues: perSource.flatMap((entry) => entry.issues),
+                parentSkips: perSource.flatMap((entry) => entry.parentSkips),
+            };
         },
         async resolveOne(idArgument) {
             const colonIndex = idArgument.indexOf(":");
@@ -52,9 +71,29 @@ export function createBoard(sources) {
                 }
                 return await callResolveOne(source, naturalId);
             }
-            const results = await Promise.all(sources.map(async (s) => await callResolveOne(s, idArgument)));
-            const matches = results.filter((r) => r !== undefined);
+            // Per-source resolveOne errors must not poison sibling resolutions.
+            // A source that rejects on a natural-id lookup is treated as "I don't
+            // have this ticket" (or "I can't say"). If any source resolved we use
+            // it; only when none resolved AND at least one rejected do we surface
+            // the rejection — so the user sees a real Linear/network error when
+            // there's no fallback, but a stray "not found" from one source doesn't
+            // mask a successful match from another.
+            const results = await Promise.allSettled(sources.map(async (s) => await callResolveOne(s, idArgument)));
+            const matches = [];
+            const rejections = [];
+            for (const result of results) {
+                if (result.status === "rejected") {
+                    rejections.push(result.reason);
+                    continue;
+                }
+                if (result.value !== undefined) {
+                    matches.push(result.value);
+                }
+            }
             if (matches.length === 0) {
+                if (rejections.length > 0) {
+                    throw rejections[0];
+                }
                 return undefined;
             }
             if (matches.length === 1) {

package/dist/lib/buildSources.d.ts

@@ -6,6 +6,7 @@
  * directory-scanned `adapterRegistry`.
  */
 import type { AdapterContext, AdapterDefinition } from "./adapterDefinition.ts";
+import type { ResolvedConfig } from "./config.ts";
 import type { TicketSource } from "./ticketSource.ts";
 /**
  * Production entry point. Awaits the directory-scanned registry, then dispatches.
@@ -16,4 +17,14 @@ export declare function buildSources(rawConfigs: readonly unknown[], context: Ad
  * import side effects.
  */
 export declare function buildSourcesWith(registry: Record<string, AdapterDefinition>, rawConfigs: readonly unknown[], context: AdapterContext): TicketSource[];
+/**
+ * Build the runtime source list from a ResolvedConfig: synthesizes the
+ * implicit Linear source (Linear is always active under the post-#110
+ * model — viewer + agent-* label filtering happens at the GraphQL layer)
+ * and appends any user-declared `sources`. The implicit source is omitted
+ * when the user already declared a Linear source (by `kind` or by runtime
+ * name "linear") so they can override its `name` / construction without
+ * spawning a duplicate adapter.
+ */
+export declare function sourcesFromConfig(config: ResolvedConfig): readonly unknown[];
 //# sourceMappingURL=buildSources.d.ts.map

package/dist/lib/buildSources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildSources.d.ts","sourceRoot":"","sources":["../../src/lib/buildSources.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAItD;;GAEG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,SAAS,OAAO,EAAE,EAC9B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,YAAY,EAAE,CAAC,CAGzB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC3C,UAAU,EAAE,SAAS,OAAO,EAAE,EAC9B,OAAO,EAAE,cAAc,GACtB,YAAY,EAAE,CAchB"}
+{"version":3,"file":"buildSources.d.ts","sourceRoot":"","sources":["../../src/lib/buildSources.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAItD;;GAEG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,SAAS,OAAO,EAAE,EAC9B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,YAAY,EAAE,CAAC,CAGzB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC3C,UAAU,EAAE,SAAS,OAAO,EAAE,EAC9B,OAAO,EAAE,cAAc,GACtB,YAAY,EAAE,CAchB;AA6BD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,OAAO,EAAE,CAM5E"}

package/dist/lib/buildSources.js

@@ -32,3 +32,44 @@ export function buildSourcesWith(registry, rawConfigs, context) {
         return adapter.create(config, context);
     });
 }
+const sourceShape = z.looseObject({
+    name: z.string().optional(),
+    kind: z.string().optional(),
+});
+/**
+ * True when `raw` is an explicitly-declared Linear source. Matches either a
+ * `kind: "linear"` entry — regardless of any `name` override — or any entry
+ * whose resolved runtime name (explicit `name`, else `kind`) is "linear".
+ * The latter catches a non-Linear adapter the user named "linear", which
+ * would otherwise collide with the implicit Linear source.
+ *
+ * Used to suppress the synthesized implicit Linear source so a renamed Linear
+ * entry like `{ kind: "linear", name: "custom" }` doesn't spawn a duplicate
+ * adapter pointed at the same viewer. Returns false for malformed entries
+ * (no `kind`/`name`) — those get rejected by the per-adapter Zod schema
+ * downstream.
+ */
+function isExplicitLinearSource(raw) {
+    const parsed = sourceShape.safeParse(raw);
+    /* v8 ignore next 3 @preserve -- looseObject() with all-optional fields only fails to parse non-object inputs (null, primitives); the same input would be rejected by the per-adapter Zod schema in buildSourcesWith, so this guard never fires in practice. */
+    if (!parsed.success) {
+        return false;
+    }
+    return parsed.data.kind === "linear" || (parsed.data.name ?? parsed.data.kind) === "linear";
+}
+/**
+ * Build the runtime source list from a ResolvedConfig: synthesizes the
+ * implicit Linear source (Linear is always active under the post-#110
+ * model — viewer + agent-* label filtering happens at the GraphQL layer)
+ * and appends any user-declared `sources`. The implicit source is omitted
+ * when the user already declared a Linear source (by `kind` or by runtime
+ * name "linear") so they can override its `name` / construction without
+ * spawning a duplicate adapter.
+ */
+export function sourcesFromConfig(config) {
+    const hasExplicitLinear = config.sources.some(isExplicitLinearSource);
+    if (hasExplicitLinear) {
+        return [...config.sources];
+    }
+    return [{ kind: "linear" }, ...config.sources];
+}

package/dist/lib/repositoryValidation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Host-level repository validation for canonical Issues. Adapters produce
+ * Issue.repository based on their own signal (Linear: agent-* label parse;
+ * shell: script JSON output). The host (dispatcher) decides whether that
+ * repository is configured for this crew via workspace.knownRepositories.
+ *
+ * WARN+skip on unknown repo is a deliberate behavior choice (P-refined in
+ * the MVP-2 plan): one badly-labelled ticket should not throw and abort
+ * the tick across N sources.
+ */
+import type { Issue } from "./ticketSource.ts";
+export declare function dispatchableRepository(issue: Issue, knownRepositories: readonly string[], log: (message: string) => void): string | undefined;
+//# sourceMappingURL=repositoryValidation.d.ts.map

package/dist/lib/repositoryValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repositoryValidation.d.ts","sourceRoot":"","sources":["../../src/lib/repositoryValidation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,KAAK,EACZ,iBAAiB,EAAE,SAAS,MAAM,EAAE,EACpC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAC7B,MAAM,GAAG,SAAS,CAWpB"}

package/dist/lib/repositoryValidation.js

@@ -0,0 +1,20 @@
+/**
+ * Host-level repository validation for canonical Issues. Adapters produce
+ * Issue.repository based on their own signal (Linear: agent-* label parse;
+ * shell: script JSON output). The host (dispatcher) decides whether that
+ * repository is configured for this crew via workspace.knownRepositories.
+ *
+ * WARN+skip on unknown repo is a deliberate behavior choice (P-refined in
+ * the MVP-2 plan): one badly-labelled ticket should not throw and abort
+ * the tick across N sources.
+ */
+export function dispatchableRepository(issue, knownRepositories, log) {
+    if (issue.repository === undefined) {
+        return undefined;
+    }
+    if (!knownRepositories.includes(issue.repository)) {
+        log(`issue ${issue.id} references unknown repository ${issue.repository}; configured workspace.knownRepositories: ${knownRepositories.join(", ") || "(none)"}`);
+        return undefined;
+    }
+    return issue.repository;
+}

package/dist/lib/testing/canonicalFixtures.d.ts

@@ -0,0 +1,19 @@
+import { type Blocker, type Issue } from "../ticketSource.ts";
+export declare function canonicalLinearIssue(overrides: Partial<Issue> & {
+    naturalId: string;
+}): Issue;
+export declare function canonicalBlocker(overrides: Partial<Blocker> & {
+    naturalId: string;
+}): Blocker;
+/**
+ * Canonical Issue fixture for a non-Linear source. Default source name is
+ * "shell-test"; override via `sourceName`. Mirrors `canonicalLinearIssue`'s
+ * defaults except `sourceRef` is an empty opaque object (no LinearSourceRef
+ * shape, since this is meant to stand in for any non-Linear adapter — the
+ * shell adapter, future Jira adapter, etc.).
+ */
+export declare function canonicalShellIssue(overrides: Partial<Issue> & {
+    naturalId: string;
+    sourceName?: string;
+}): Issue;
+//# sourceMappingURL=canonicalFixtures.d.ts.map

package/dist/lib/testing/canonicalFixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalFixtures.d.ts","sourceRoot":"","sources":["../../../src/lib/testing/canonicalFixtures.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAAiB,MAAM,oBAAoB,CAAC;AAE7E,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,KAAK,CA0B7F;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAQ7F;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACrE,KAAK,CAiBP"}