@creativeintelligence/abbie 0.1.0

package/dist/lib/triage-llm.js

@@ -0,0 +1,269 @@
+import { spawnSync } from "node:child_process";
+import { telemetry } from "./analytics.js";
+import { AGENT_CAPABILITIES } from "./types.js";
+/**
+ * Classification prompt template.
+ */
+const CLASSIFICATION_PROMPT = `You are a technical project manager triaging Linear issues for an AI coding assistant system.
+
+<issue>
+<identifier>{{IDENTIFIER}}</identifier>
+<title>{{TITLE}}</title>
+<description>
+{{DESCRIPTION}}
+</description>
+<priority>{{PRIORITY}}</priority>
+<labels>{{LABELS}}</labels>
+</issue>
+
+<context>
+This is for Zo Computer, a cloud development environment with AI coding assistance.
+Tech stack: Next.js 15, React 19, FastAPI, Modal, Neon Postgres, Cloudflare Workers.
+The codebase is a monorepo with Python backend and TypeScript frontend.
+</context>
+
+<task>
+Classify this issue for agent assignment. Consider:
+1. **Type**: What kind of work is this?
+2. **Complexity**: How much effort/scope?
+3. **Agent**: Which agent is best suited?
+4. **Prompt**: What should we tell the agent?
+</task>
+
+<output_contract>
+Respond with ONLY valid JSON matching this schema:
+{
+  "type": "bug" | "feature" | "refactor" | "improvement" | "chore",
+  "complexity": "trivial" | "simple" | "medium" | "complex" | "epic",
+  "agent": "copilot" | "claude" | "codex" | "human",
+  "confidence": 1-10,
+  "reasoning": "2-3 sentences explaining classification",
+  "suggested_prompt": "specific instructions for the agent",
+  "tags": ["relevant", "tags"]
+}
+
+Agent capabilities:
+- copilot: Quick, good for simple bugs, chores, low-scope improvements (simple complexity max)
+- claude: Orchestrator, good for features, improvements, moderate refactors (medium complexity max)
+- codex: Implementer, deep reasoning, good for complex features and architecture work (complex max)
+- human: Epic scope, ambiguous requirements, needs product decisions
+
+Complexity guide:
+- trivial: typo, copy change, single line fix
+- simple: single file change, clear requirements
+- medium: 2-5 files, some design decisions
+- complex: cross-cutting concerns, architecture impact
+- epic: multi-week, needs breakdown
+</output_contract>`;
+/**
+ * Build classification prompt for an issue.
+ */
+function buildPrompt(issue) {
+    const labels = issue.labels.nodes.map((l) => l.name).join(", ") || "none";
+    return CLASSIFICATION_PROMPT.replace("{{IDENTIFIER}}", issue.identifier)
+        .replace("{{TITLE}}", issue.title)
+        .replace("{{DESCRIPTION}}", issue.description || "No description provided.")
+        .replace("{{PRIORITY}}", issue.priorityLabel)
+        .replace("{{LABELS}}", labels);
+}
+/**
+ * Parse LLM response into structured classification.
+ */
+function parseResponse(response) {
+    const validTypes = ["bug", "feature", "refactor", "improvement", "chore"];
+    const validComplexities = ["trivial", "simple", "medium", "complex", "epic"];
+    const validAgents = AGENT_CAPABILITIES;
+    const normalize = (candidate) => {
+        const parsed = typeof candidate === "object" && candidate !== null
+            ? candidate
+            : {};
+        const type = typeof parsed.type === "string" && validTypes.includes(parsed.type)
+            ? parsed.type
+            : "improvement";
+        const complexity = typeof parsed.complexity === "string" &&
+            validComplexities.includes(parsed.complexity)
+            ? parsed.complexity
+            : "medium";
+        const agent = typeof parsed.agent === "string" && validAgents.includes(parsed.agent)
+            ? parsed.agent
+            : "claude";
+        const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 5;
+        const reasoning = typeof parsed.reasoning === "string" ? parsed.reasoning : "No reasoning provided";
+        const suggested_prompt = typeof parsed.suggested_prompt === "string" ? parsed.suggested_prompt : `Work on: ${type}`;
+        const tags = Array.isArray(parsed.tags)
+            ? parsed.tags.filter((t) => typeof t === "string")
+            : [];
+        return {
+            type,
+            complexity,
+            agent,
+            confidence: Math.min(10, Math.max(1, confidence)),
+            reasoning,
+            suggested_prompt,
+            tags,
+            raw_response: response,
+        };
+    };
+    const trimmed = response.trim();
+    // 1) Try raw JSON
+    try {
+        const direct = JSON.parse(trimmed);
+        if (typeof direct?.result === "string") {
+            // wrapper-style
+            const inner = direct.result.trim();
+            const match = inner.match(/\{[\s\S]*\}/);
+            if (!match)
+                return null;
+            return normalize(JSON.parse(match[0]));
+        }
+        return normalize(direct);
+    }
+    catch {
+        // continue
+    }
+    // 2) Try to extract JSON object from noisy output
+    const match = trimmed.match(/\{[\s\S]*\}/);
+    if (!match)
+        return null;
+    try {
+        return normalize(JSON.parse(match[0]));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a binary is available on PATH.
+ */
+function isBinaryAvailable(bin) {
+    const result = spawnSync("which", [bin], { stdio: "pipe" });
+    return result.status === 0;
+}
+/**
+ * Classify an issue using an LLM (gemini CLI preferred, fallback to copilot).
+ */
+export async function classifyWithLLM(issue) {
+    const prompt = buildPrompt(issue);
+    const canUseGemini = isBinaryAvailable("gemini");
+    const canUseCopilot = isBinaryAvailable("copilot");
+    try {
+        if (!canUseGemini && !canUseCopilot) {
+            telemetry.trackEscalation("llm", "heuristic", "no llm cli available");
+            return fallbackClassification(issue);
+        }
+        // Track escalation when gemini unavailable
+        if (!canUseGemini && canUseCopilot) {
+            telemetry.trackEscalation("gemini", "copilot", "gemini unavailable for triage");
+        }
+        const result = canUseGemini
+            ? spawnSync("gemini", ["-p", prompt, "-m", "gemini-3-flash"], {
+                encoding: "utf-8",
+                timeout: 60000,
+                stdio: ["ignore", "pipe", "pipe"],
+            })
+            : spawnSync("copilot", [
+                "-p",
+                prompt,
+                "--model",
+                "gemini-3-pro-preview",
+                "--yolo",
+                "--silent",
+                "--stream",
+                "off",
+            ], {
+                encoding: "utf-8",
+                timeout: 60000,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        const stdout = result.stdout?.toString?.() ?? String(result.stdout ?? "");
+        const stderr = result.stderr?.toString?.() ?? String(result.stderr ?? "");
+        if (result.status !== 0) {
+            const fromAgent = canUseGemini ? "gemini" : "copilot";
+            telemetry.trackEscalation(fromAgent, "heuristic", `exit ${result.status ?? "unknown"}`);
+            return {
+                ...fallbackClassification(issue),
+                raw_response: [stdout, stderr].filter(Boolean).join("\n"),
+                reasoning: `LLM classification failed (exit ${result.status ?? "unknown"}), using fallback classification`,
+            };
+        }
+        const parsed = parseResponse(stdout);
+        if (parsed) {
+            return parsed;
+        }
+        // If parsing failed, try to extract what we can
+        const fromAgent = canUseGemini ? "gemini" : "copilot";
+        telemetry.trackEscalation(fromAgent, "heuristic", "parse failure");
+        return {
+            ...fallbackClassification(issue),
+            raw_response: stdout,
+            reasoning: "LLM response could not be parsed, using fallback classification",
+        };
+    }
+    catch (err) {
+        // On error, fall back to heuristic
+        telemetry.trackEscalation("llm", "heuristic", err.message);
+        return {
+            ...fallbackClassification(issue),
+            reasoning: `LLM classification failed: ${err.message}`,
+        };
+    }
+}
+/**
+ * Fallback heuristic classification when LLM unavailable.
+ */
+function fallbackClassification(issue) {
+    const text = `${issue.title} ${issue.description || ""}`.toLowerCase();
+    // Simple keyword-based fallback
+    let type = "improvement";
+    if (/\b(bug|fix|broke|error|crash|fail)\b/i.test(text))
+        type = "bug";
+    else if (/\b(add|new|implement|create|feature)\b/i.test(text))
+        type = "feature";
+    else if (/\b(refactor|restructure|cleanup)\b/i.test(text))
+        type = "refactor";
+    else if (/\b(chore|deps|test|docs)\b/i.test(text))
+        type = "chore";
+    // Estimate complexity from title length
+    const words = issue.title.split(/\s+/).length;
+    let complexity = "simple";
+    if (words <= 4)
+        complexity = "trivial";
+    else if (words <= 7)
+        complexity = "simple";
+    else if (words <= 12)
+        complexity = "medium";
+    else
+        complexity = "complex";
+    // Map to agent
+    let agent = "claude";
+    if (complexity === "trivial" || complexity === "simple")
+        agent = "copilot";
+    else if (complexity === "complex")
+        agent = "codex";
+    return {
+        type,
+        complexity,
+        agent,
+        confidence: 4, // Low confidence for fallback
+        reasoning: "Fallback heuristic classification (LLM unavailable)",
+        suggested_prompt: `Work on ${issue.identifier}: ${issue.title}`,
+        tags: issue.labels.nodes.map((l) => l.name.toLowerCase()),
+    };
+}
+/**
+ * Batch classify multiple issues (sequentially to avoid rate limits).
+ */
+export async function classifyBatch(issues, onProgress) {
+    const results = new Map();
+    for (let i = 0; i < issues.length; i++) {
+        const issue = issues[i];
+        onProgress?.(i + 1, issues.length);
+        const classification = await classifyWithLLM(issue);
+        results.set(issue.identifier, classification);
+        // Small delay between calls to avoid rate limiting
+        if (i < issues.length - 1) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+    }
+    return results;
+}

package/dist/lib/triage-tracker.d.ts

@@ -0,0 +1,72 @@
+import type { LinearIssue } from "./triage.js";
+import type { LLMClassification } from "./triage-llm.js";
+/**
+ * Tracking issue status.
+ */
+export type TrackingStatus = "pending" | "claimed" | "in_progress" | "blocked" | "done";
+/**
+ * Tracking issue record.
+ */
+export interface TrackingIssue {
+    source_workspace: string;
+    source_team: string;
+    source_identifier: string;
+    source_url: string;
+    source_title: string;
+    tracking_workspace: string;
+    tracking_team: string;
+    tracking_identifier?: string;
+    tracking_url?: string;
+    classification: LLMClassification;
+    status: TrackingStatus;
+    claimed_at?: string;
+    updated_at: string;
+    agent_session?: string;
+    progress_notes: string[];
+}
+/**
+ * Tracking registry stored on disk.
+ */
+export interface TrackingRegistry {
+    version: number;
+    updated_at: string;
+    issues: Record<string, TrackingIssue>;
+}
+/**
+ * Create tracking issue in luke-labs/ZO.
+ */
+export declare function createTrackingIssue(source: LinearIssue, classification: LLMClassification, options: {
+    sourceWorkspace: string;
+    sourceTeam: string;
+    trackingWorkspace: string;
+    trackingTeam: string;
+    dryRun?: boolean;
+}): Promise<TrackingIssue>;
+/**
+ * Load tracking registry.
+ */
+export declare function loadRegistry(): TrackingRegistry;
+/**
+ * Update tracking issue status.
+ */
+export declare function updateTrackingStatus(sourceIdentifier: string, status: TrackingStatus, note?: string): TrackingIssue | null;
+/**
+ * Check if an issue is already tracked.
+ */
+export declare function isTracked(sourceIdentifier: string): TrackingIssue | null;
+/**
+ * Get all tracked issues.
+ */
+export declare function getTrackedIssues(): TrackingIssue[];
+/**
+ * Get tracked issues by status.
+ */
+export declare function getTrackedByStatus(status: TrackingStatus): TrackingIssue[];
+/**
+ * Ensure required labels exist in workspace.
+ */
+export declare function ensureLabels(workspace: string, team: string): Promise<{
+    created: string[];
+    existing: string[];
+}>;
+//# sourceMappingURL=triage-tracker.d.ts.map

package/dist/lib/triage-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-tracker.d.ts","sourceRoot":"","sources":["../../src/lib/triage-tracker.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,GAAG,MAAM,CAAC;AAExF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,iBAAiB,CAAC;IAClC,MAAM,EAAE,cAAc,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACvC;AA6FD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,WAAW,EACnB,cAAc,EAAE,iBAAiB,EACjC,OAAO,EAAE;IACP,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,GACA,OAAO,CAAC,aAAa,CAAC,CA8ExB;AAaD;;GAEG;AACH,wBAAgB,YAAY,IAAI,gBAAgB,CAmB/C;AAcD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,cAAc,EACtB,IAAI,CAAC,EAAE,MAAM,GACZ,aAAa,GAAG,IAAI,CA6CtB;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,gBAAgB,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAGxE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,EAAE,CAGlD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,aAAa,EAAE,CAE1E;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA2CpD"}

package/dist/lib/triage-tracker.js

@@ -0,0 +1,301 @@
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Build the issue description with full context packet.
+ */
+function buildTrackingDescription(source, classification) {
+    const sourceUrl = `https://linear.app/zocomputer/issue/${source.identifier}`;
+    return `## Source Issue
+
+**[${source.identifier}](${sourceUrl})**: ${source.title}
+
+---
+
+## Classification
+
+| Field | Value |
+|-------|-------|
+| Type | \`${classification.type}\` |
+| Complexity | \`${classification.complexity}\` |
+| Agent | \`${classification.agent}\` |
+| Confidence | ${classification.confidence}/10 |
+
+### Reasoning
+
+${classification.reasoning}
+
+### Tags
+
+${classification.tags.length > 0 ? classification.tags.map((t) => `\`${t}\``).join(", ") : "_none_"}
+
+---
+
+## Agent Prompt
+
+\`\`\`
+${classification.suggested_prompt}
+\`\`\`
+
+---
+
+## Original Description
+
+${source.description || "_No description provided._"}
+
+---
+
+## Progress Log
+
+_Updates will be added here as work progresses._
+`;
+}
+/**
+ * Build issue title for tracking.
+ */
+function buildTrackingTitle(source, classification) {
+    return `[${classification.agent}] ${source.identifier}: ${source.title}`;
+}
+/**
+ * Map internal complexity to Linear label names.
+ */
+function mapComplexityToLabel(complexity) {
+    const mapping = {
+        trivial: "low",
+        simple: "low",
+        medium: "medium",
+        complex: "high",
+        epic: "xhigh",
+    };
+    return mapping[complexity] || "medium";
+}
+/**
+ * Get labels to apply based on classification.
+ * Uses hierarchical label names: agent/claude, complexity/medium
+ */
+function getTrackingLabels(classification) {
+    const labels = [];
+    // Agent label (child of 'agent' group) - skip 'human'
+    if (classification.agent !== "human") {
+        labels.push(classification.agent);
+    }
+    // Complexity label (child of 'complexity' group)
+    const complexityLabel = mapComplexityToLabel(classification.complexity);
+    labels.push(complexityLabel);
+    return labels;
+}
+/**
+ * Create tracking issue in luke-labs/ZO.
+ */
+export async function createTrackingIssue(source, classification, options) {
+    const title = buildTrackingTitle(source, classification);
+    const description = buildTrackingDescription(source, classification);
+    const labels = getTrackingLabels(classification);
+    const tracking = {
+        source_workspace: options.sourceWorkspace,
+        source_team: options.sourceTeam,
+        source_identifier: source.identifier,
+        source_url: `https://linear.app/${options.sourceWorkspace}/issue/${source.identifier}`,
+        source_title: source.title,
+        tracking_workspace: options.trackingWorkspace,
+        tracking_team: options.trackingTeam,
+        classification,
+        status: "claimed",
+        claimed_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        progress_notes: [],
+    };
+    if (options.dryRun) {
+        tracking.tracking_identifier = `${options.trackingTeam}-DRY`;
+        return tracking;
+    }
+    try {
+        // Create issue via linear CLI
+        // Note: labels may not exist yet, so we create without labels first
+        const createCmd = [
+            "linear issue create",
+            `--team ${options.trackingTeam}`,
+            `--workspace ${options.trackingWorkspace}`,
+            `--title "${title.replace(/"/g, '\\"')}"`,
+            "--json",
+            "--quiet",
+        ].join(" ");
+        // Write description to temp file to avoid shell escaping issues
+        const tempFile = `/tmp/tracking-desc-${Date.now()}.md`;
+        writeFileSync(tempFile, description);
+        const result = execSync(`${createCmd} --description "$(cat ${tempFile})"`, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // Clean up temp file
+        try {
+            execSync(`rm ${tempFile}`, { stdio: "ignore" });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        // Parse result to get issue identifier (nested under 'issue')
+        const parsed = JSON.parse(result);
+        const identifier = parsed.issue?.identifier || parsed.identifier;
+        tracking.tracking_identifier = identifier;
+        tracking.tracking_url = `https://linear.app/${options.trackingWorkspace}/issue/${identifier}`;
+        // Try to add labels (may fail if labels don't exist)
+        for (const label of labels) {
+            try {
+                execSync(`linear issue edit ${tracking.tracking_identifier} --add-label "${label}" --workspace ${options.trackingWorkspace} --quiet`, { stdio: "ignore" });
+            }
+            catch {
+                // Label may not exist, continue
+            }
+        }
+        // Save to registry
+        saveToRegistry(tracking);
+        return tracking;
+    }
+    catch (err) {
+        throw new Error(`Failed to create tracking issue: ${err.message}`);
+    }
+}
+/**
+ * Get registry path.
+ */
+function getRegistryPath() {
+    const dir = join(homedir(), ".abbie", "triage");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return join(dir, "tracking-registry.json");
+}
+/**
+ * Load tracking registry.
+ */
+export function loadRegistry() {
+    const path = getRegistryPath();
+    if (!existsSync(path)) {
+        return {
+            version: 1,
+            updated_at: new Date().toISOString(),
+            issues: {},
+        };
+    }
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return {
+            version: 1,
+            updated_at: new Date().toISOString(),
+            issues: {},
+        };
+    }
+}
+/**
+ * Save tracking issue to registry.
+ */
+function saveToRegistry(tracking) {
+    const registry = loadRegistry();
+    registry.issues[tracking.source_identifier] = tracking;
+    registry.updated_at = new Date().toISOString();
+    const path = getRegistryPath();
+    writeFileSync(path, JSON.stringify(registry, null, 2));
+}
+/**
+ * Update tracking issue status.
+ */
+export function updateTrackingStatus(sourceIdentifier, status, note) {
+    const registry = loadRegistry();
+    const tracking = registry.issues[sourceIdentifier];
+    if (!tracking)
+        return null;
+    tracking.status = status;
+    tracking.updated_at = new Date().toISOString();
+    if (note) {
+        tracking.progress_notes.push(`[${new Date().toISOString()}] ${note}`);
+    }
+    saveToRegistry(tracking);
+    // Also update Linear issue if we have tracking identifier
+    if (tracking.tracking_identifier && tracking.tracking_workspace) {
+        try {
+            // Map status to Linear state
+            const stateMap = {
+                pending: "Backlog",
+                claimed: "Todo",
+                in_progress: "In Progress",
+                blocked: "Todo", // No blocked state, use Todo
+                done: "Done",
+            };
+            execSync(`linear issue edit ${tracking.tracking_identifier} --state "${stateMap[status]}" --workspace ${tracking.tracking_workspace} --quiet`, { stdio: "ignore" });
+            // Add comment for progress note
+            if (note) {
+                execSync(`linear comment create -i ${tracking.tracking_identifier} -b "${note}" --workspace ${tracking.tracking_workspace} --quiet`, { stdio: "ignore" });
+            }
+        }
+        catch {
+            // Ignore Linear update errors
+        }
+    }
+    return tracking;
+}
+/**
+ * Check if an issue is already tracked.
+ */
+export function isTracked(sourceIdentifier) {
+    const registry = loadRegistry();
+    return registry.issues[sourceIdentifier] || null;
+}
+/**
+ * Get all tracked issues.
+ */
+export function getTrackedIssues() {
+    const registry = loadRegistry();
+    return Object.values(registry.issues);
+}
+/**
+ * Get tracked issues by status.
+ */
+export function getTrackedByStatus(status) {
+    return getTrackedIssues().filter((t) => t.status === status);
+}
+/**
+ * Ensure required labels exist in workspace.
+ */
+export async function ensureLabels(workspace, team) {
+    const requiredLabels = [
+        // Agent labels
+        "agent:claude",
+        "agent:codex",
+        "agent:copilot",
+        "agent:gemini",
+        "agent:human",
+        // Complexity labels
+        "complexity:trivial",
+        "complexity:simple",
+        "complexity:medium",
+        "complexity:complex",
+        "complexity:epic",
+        // Confidence labels
+        "confidence:high",
+        "confidence:medium",
+        "confidence:low",
+        // Type labels
+        "type:bug",
+        "type:feature",
+        "type:refactor",
+        "type:improvement",
+        "type:chore",
+    ];
+    const created = [];
+    const existing = [];
+    for (const label of requiredLabels) {
+        try {
+            execSync(`linear label create --name "${label}" --team ${team} --workspace ${workspace} --quiet`, { stdio: "ignore" });
+            created.push(label);
+        }
+        catch {
+            // Label likely exists
+            existing.push(label);
+        }
+    }
+    return { created, existing };
+}