@a5c-ai/tasks-adapter 5.1.1-staging.0007199a1cb2

package/dist/backends/index.d.ts

@@ -0,0 +1,52 @@
+import type { BreakpointBackend } from "../backend.js";
+import type { BreakpointContext, BackendConfig, RoutingConfig } from "../types.js";
+export { ServerBreakpointBackend, ServerBackendError } from "./server.js";
+export type { ServerBreakpointBackendConfig } from "./server.js";
+export { ExternalTrackerBackend, GenericRestTrackerAdapter, JiraTrackerAdapter, LinearTrackerAdapter, createExternalTrackerAdapter, redactExternalTrackerSecrets, } from "./external-tracker.js";
+export type { ExternalTrackerAdapter, ExternalTrackerComment, ExternalTrackerCreateIssueInput, ExternalTrackerIssue, ExternalTrackerReference, ExternalTrackerWebhookEvent, ExternalTrackerWebhookResult, } from "./external-tracker.js";
+export { AgentMuxResponderBackend, AgentMuxResponderBackendError, } from "./adapters.js";
+export type { AgentMuxClientLike, AgentMuxResponderBackendConfig, AgentMuxRunHandleLike, AgentMuxRunOptions, AgentMuxRunResult, } from "./adapters.js";
+/**
+ * Factory function type for creating backends from config.
+ */
+export type BackendFactory = (config: Record<string, unknown>) => BreakpointBackend;
+/**
+ * Register a custom backend factory.
+ * Called by extension packages (e.g., custom server backend, GitHub Issues backend).
+ */
+export declare function registerBackendFactory(name: string, factory: BackendFactory): void;
+/**
+ * Create a backend from a type name and config object.
+ * Validates at runtime that the factory returns a BreakpointBackend-conforming object.
+ */
+export declare function createBackend(type: string, config: Record<string, unknown>): BreakpointBackend;
+/**
+ * Create the default git-native backend with optional config.
+ *
+ * This is the recommended entry point for consumers who want the built-in
+ * backend without explicit configuration.
+ */
+export declare function createDefaultBackend(options?: Record<string, unknown>): BreakpointBackend;
+/**
+ * Resolve the backend for a given config, falling back to defaults.
+ */
+export declare function resolveBackend(config: BackendConfig): BreakpointBackend;
+/**
+ * Match a routing config against a breakpoint context to find the appropriate backend name.
+ *
+ * Uses **first-match-wins** semantics: routes are evaluated in array order and the
+ * first rule whose domain or tag criteria match the context is selected. If no rule
+ * matches, the `defaultBackend` is returned. This means higher-priority rules should
+ * appear earlier in the routes array. There is no automatic conflict resolution --
+ * if multiple rules could match, the first one in array order wins.
+ *
+ * Matching logic per rule (short-circuit on first hit):
+ * 1. If the rule specifies `domains` and the context has a `domain`, check membership.
+ * 2. If the rule specifies `tags` and the context has tags, check intersection.
+ */
+export declare function matchRoute(routingConfig: RoutingConfig, context: BreakpointContext): string;
+/**
+ * List all registered backend types.
+ */
+export declare function listRegisteredBackends(): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/backends/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/backends/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,aAAa,EAId,MAAM,aAAa,CAAC;AASrB,OAAO,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAC1E,YAAY,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,kBAAkB,EAClB,oBAAoB,EACpB,4BAA4B,EAC5B,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,sBAAsB,EACtB,sBAAsB,EACtB,+BAA+B,EAC/B,oBAAoB,EACpB,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,wBAAwB,EACxB,6BAA6B,GAC9B,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,kBAAkB,EAClB,8BAA8B,EAC9B,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAEvB;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,iBAAiB,CAAC;AAgGpF;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,cAAc,GACtB,IAAI,CAEN;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,iBAAiB,CAYnB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,iBAAiB,CAEnB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,GACpB,iBAAiB,CAEnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CACxB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,iBAAiB,GACzB,MAAM,CAUR;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD"}

package/dist/backends/index.js

@@ -0,0 +1,151 @@
+import { GitNativeBackend } from "./git-native.js";
+import { GitHubIssuesBackend } from "./github-issues.js";
+import { ExternalTrackerBackend } from "./external-tracker.js";
+import { ServerBreakpointBackend } from "./server.js";
+import { AgentMuxResponderBackend } from "./adapters.js";
+export { ServerBreakpointBackend, ServerBackendError } from "./server.js";
+export { ExternalTrackerBackend, GenericRestTrackerAdapter, JiraTrackerAdapter, LinearTrackerAdapter, createExternalTrackerAdapter, redactExternalTrackerSecrets, } from "./external-tracker.js";
+export { AgentMuxResponderBackend, AgentMuxResponderBackendError, } from "./adapters.js";
+/**
+ * Registry of backend factories.
+ */
+const backendFactories = new Map();
+// Register the built-in git-native backend
+backendFactories.set("git-native", (config) => {
+    return new GitNativeBackend(config);
+});
+// Register the GitHub Issues backend
+backendFactories.set("github-issues", (config) => {
+    return new GitHubIssuesBackend(config);
+});
+// Register the provider-neutral external tracker backend
+backendFactories.set("external-tracker", (config) => {
+    return new ExternalTrackerBackend(config);
+});
+// Register the adapters responder backend
+backendFactories.set("adapters", (config) => {
+    return new AgentMuxResponderBackend(config);
+});
+// Register the breakpoints-pro server backend
+backendFactories.set("server", (config) => {
+    const serverUrl = config.url
+        ?? config.serverUrl;
+    if (!serverUrl) {
+        throw new Error('Server backend requires a "url" or "serverUrl" property in config. ' +
+            'Example: { type: "server", url: "http://localhost:3847" }');
+    }
+    return new ServerBreakpointBackend({
+        serverUrl,
+        authToken: config.authToken,
+        projectId: config.projectId,
+        repoId: config.repoId,
+    });
+});
+/**
+ * Required method names on the BreakpointBackend interface.
+ * Used for runtime validation that factory-produced objects conform to the contract.
+ */
+const REQUIRED_BACKEND_METHODS = [
+    "submitBreakpoint",
+    "getBreakpoint",
+    "waitForAnswer",
+    "listPendingBreakpoints",
+    "answerBreakpoint",
+    "cancelBreakpoint",
+];
+/**
+ * Validate that an object conforms to the BreakpointBackend interface at runtime.
+ * Checks for the `name` property and all required methods.
+ * Throws a descriptive error if validation fails.
+ */
+function validateBackendConformance(backend, type) {
+    if (backend === null || backend === undefined || typeof backend !== "object") {
+        throw new Error(`Backend factory for "${type}" returned ${backend === null ? "null" : typeof backend} ` +
+            `instead of a BreakpointBackend-conforming object.`);
+    }
+    const obj = backend;
+    if (typeof obj.name !== "string" || obj.name.length === 0) {
+        throw new Error(`Backend factory for "${type}" returned an object without a valid "name" property. ` +
+            `BreakpointBackend requires a non-empty readonly name string.`);
+    }
+    const missingMethods = [];
+    for (const method of REQUIRED_BACKEND_METHODS) {
+        if (typeof obj[method] !== "function") {
+            missingMethods.push(method);
+        }
+    }
+    if (missingMethods.length > 0) {
+        throw new Error(`Backend factory for "${type}" returned an object missing required methods: ` +
+            `${missingMethods.join(", ")}. ` +
+            `BreakpointBackend requires: name, ${REQUIRED_BACKEND_METHODS.join(", ")}.`);
+    }
+}
+/**
+ * Register a custom backend factory.
+ * Called by extension packages (e.g., custom server backend, GitHub Issues backend).
+ */
+export function registerBackendFactory(name, factory) {
+    backendFactories.set(name, factory);
+}
+/**
+ * Create a backend from a type name and config object.
+ * Validates at runtime that the factory returns a BreakpointBackend-conforming object.
+ */
+export function createBackend(type, config) {
+    const factory = backendFactories.get(type);
+    if (!factory) {
+        throw new Error(`Unknown backend type: "${type}". ` +
+            `Available: ${[...backendFactories.keys()].join(", ")}. ` +
+            `Use registerBackendFactory() to add custom backends.`);
+    }
+    const backend = factory(config);
+    validateBackendConformance(backend, type);
+    return backend;
+}
+/**
+ * Create the default git-native backend with optional config.
+ *
+ * This is the recommended entry point for consumers who want the built-in
+ * backend without explicit configuration.
+ */
+export function createDefaultBackend(options) {
+    return new GitNativeBackend(options);
+}
+/**
+ * Resolve the backend for a given config, falling back to defaults.
+ */
+export function resolveBackend(config) {
+    return createBackend(config.type, config);
+}
+/**
+ * Match a routing config against a breakpoint context to find the appropriate backend name.
+ *
+ * Uses **first-match-wins** semantics: routes are evaluated in array order and the
+ * first rule whose domain or tag criteria match the context is selected. If no rule
+ * matches, the `defaultBackend` is returned. This means higher-priority rules should
+ * appear earlier in the routes array. There is no automatic conflict resolution --
+ * if multiple rules could match, the first one in array order wins.
+ *
+ * Matching logic per rule (short-circuit on first hit):
+ * 1. If the rule specifies `domains` and the context has a `domain`, check membership.
+ * 2. If the rule specifies `tags` and the context has tags, check intersection.
+ */
+export function matchRoute(routingConfig, context) {
+    for (const rule of routingConfig.routes) {
+        if (rule.domains && context.domain) {
+            if (rule.domains.includes(context.domain))
+                return rule.backend;
+        }
+        if (rule.tags && context.tags.length > 0) {
+            if (rule.tags.some((t) => context.tags.includes(t)))
+                return rule.backend;
+        }
+    }
+    return routingConfig.defaultBackend;
+}
+/**
+ * List all registered backend types.
+ */
+export function listRegisteredBackends() {
+    return [...backendFactories.keys()];
+}

package/dist/backends/server.d.ts

@@ -0,0 +1,42 @@
+/**
+ * ServerBreakpointBackend -- BreakpointBackend implementation backed by the
+ * breakpoints-pro HTTP server.
+ *
+ * Bridges tasks-adapter naming (Breakpoint / Responder) to the server's
+ * internal naming (Question / Expert) by translating HTTP payloads.
+ * Communicates exclusively via fetch(), so it can run in any environment.
+ */
+import type { BreakpointBackend, BreakpointBackendCapabilities, SubmitBreakpointParams, WaitForAnswerOptions, SubmitAnswerParams, ListRespondersParams } from "../backend.js";
+import type { Breakpoint, BreakpointAnswer, BreakpointWaitResult, ResponderProfile } from "../types.js";
+export interface ServerBreakpointBackendConfig {
+    serverUrl: string;
+    authToken?: string;
+    projectId?: string;
+    repoId?: string;
+}
+export declare class ServerBackendError extends Error {
+    readonly statusCode: number;
+    readonly responseBody?: unknown | undefined;
+    constructor(message: string, statusCode: number, responseBody?: unknown | undefined);
+}
+export declare class ServerBreakpointBackend implements BreakpointBackend {
+    readonly name = "server";
+    private serverUrl;
+    private authToken;
+    private projectId;
+    private repoId;
+    constructor(config: ServerBreakpointBackendConfig);
+    capabilities(): BreakpointBackendCapabilities;
+    private buildUrl;
+    private buildHeaders;
+    private request;
+    submitBreakpoint(params: SubmitBreakpointParams): Promise<Breakpoint>;
+    getBreakpoint(id: string): Promise<Breakpoint>;
+    waitForAnswer(id: string, options?: WaitForAnswerOptions): Promise<BreakpointWaitResult>;
+    listPendingBreakpoints(responderId?: string): Promise<Breakpoint[]>;
+    answerBreakpoint(id: string, answer: SubmitAnswerParams): Promise<BreakpointAnswer>;
+    cancelBreakpoint(id: string): Promise<void>;
+    listResponders(params?: ListRespondersParams): Promise<ResponderProfile[]>;
+    claimBreakpoint(id: string, responderId: string): Promise<Breakpoint>;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/backends/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/backends/server.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,6BAA6B,EAC7B,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAEhB,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAWrB,MAAM,WAAW,6BAA6B;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAID,qBAAa,kBAAmB,SAAQ,KAAK;aAGzB,UAAU,EAAE,MAAM;aAClB,YAAY,CAAC,EAAE,OAAO;gBAFtC,OAAO,EAAE,MAAM,EACC,UAAU,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,OAAO,YAAA;CAKzC;AAwID,qBAAa,uBAAwB,YAAW,iBAAiB;IAC/D,QAAQ,CAAC,IAAI,YAAY;IAEzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,MAAM,CAAqB;gBAEvB,MAAM,EAAE,6BAA6B;IAOjD,YAAY,IAAI,6BAA6B;IAO7C,OAAO,CAAC,QAAQ;IAYhB,OAAO,CAAC,YAAY;YAUN,OAAO;IAmCf,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,UAAU,CAAC;IAwCrE,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAS9C,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAqFxF,sBAAsB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAkCnE,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA4BnF,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO3C,cAAc,CAAC,MAAM,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAkB1E,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAa5E"}

package/dist/backends/server.js

@@ -0,0 +1,305 @@
+/**
+ * ServerBreakpointBackend -- BreakpointBackend implementation backed by the
+ * breakpoints-pro HTTP server.
+ *
+ * Bridges tasks-adapter naming (Breakpoint / Responder) to the server's
+ * internal naming (Question / Expert) by translating HTTP payloads.
+ * Communicates exclusively via fetch(), so it can run in any environment.
+ */
+import { BreakpointSchema, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS } from "../types.js";
+import { unsupportedBackendFeatureMessage as unsupportedFeatureMessage, unsupportedBreakpointBackendCapabilities, } from "../backend.js";
+const API_BASE_PATH = "/api/v1";
+// ── Error ───────────────────────────────────────────────────────────────
+export class ServerBackendError extends Error {
+    statusCode;
+    responseBody;
+    constructor(message, statusCode, responseBody) {
+        super(message);
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.name = "ServerBackendError";
+    }
+}
+// ── Mapping helpers ─────────────────────────────────────────────────────
+function mapServerAnswerToBreakpointAnswer(answer) {
+    return {
+        id: answer.id,
+        breakpointId: answer.questionId,
+        responderId: answer.expertId,
+        responderName: answer.expertName,
+        text: answer.text,
+        confidence: answer.confidence,
+        references: answer.references,
+        followUpQuestions: answer.followUpQuestions,
+        answeredAt: answer.answeredAt,
+        approved: answer.approved,
+        rating: answer.rating,
+        decisionMemory: answer.decisionMemory,
+    };
+}
+function mapServerQuestionToBreakpoint(question) {
+    const context = question.context;
+    return BreakpointSchema.parse({
+        id: question.id,
+        text: question.text,
+        context,
+        status: question.status,
+        routing: {
+            strategy: question.routing.strategy,
+            targetResponders: question.routing.targetExperts,
+            timeoutMs: question.routing.timeoutMs,
+            presentToUser: question.routing.presentToUser,
+        },
+        answers: question.answers.map(mapServerAnswerToBreakpointAnswer),
+        selectedAnswer: question.selectedAnswer,
+        projectId: question.projectId,
+        repoId: question.repoId,
+        createdBy: question.createdBy,
+        claimedByResponderId: question.claimedByExpertId,
+        claimedByResponderName: question.claimedByExpertName,
+        createdAt: question.createdAt,
+        updatedAt: question.updatedAt,
+        expiresAt: question.expiresAt,
+    });
+}
+function mapExpertProfileToResponderProfile(expert) {
+    const allDomains = expert.expertiseAreas.map((area) => area.domain);
+    const allTags = expert.expertiseAreas.flatMap((area) => [...area.topics, ...area.keywords]);
+    return {
+        id: expert.id,
+        name: expert.name,
+        title: expert.title,
+        domains: allDomains,
+        tags: allTags,
+        availability: expert.availability,
+        responseTimeSla: expert.responseTimeSla,
+    };
+}
+// ── Backend implementation ──────────────────────────────────────────────
+export class ServerBreakpointBackend {
+    name = "server";
+    serverUrl;
+    authToken;
+    projectId;
+    repoId;
+    constructor(config) {
+        this.serverUrl = config.serverUrl.replace(/\/+$/, "");
+        this.authToken = config.authToken;
+        this.projectId = config.projectId;
+        this.repoId = config.repoId;
+    }
+    capabilities() {
+        return {
+            ...unsupportedBreakpointBackendCapabilities,
+            assignment: true,
+        };
+    }
+    buildUrl(path, params) {
+        const url = new URL(`${this.serverUrl}${path}`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined) {
+                    url.searchParams.set(key, value);
+                }
+            }
+        }
+        return url.toString();
+    }
+    buildHeaders() {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.authToken) {
+            headers["Authorization"] = `Bearer ${this.authToken}`;
+        }
+        return headers;
+    }
+    async request(method, path, options) {
+        const url = this.buildUrl(path, options?.params);
+        const response = await fetch(url, {
+            method,
+            headers: this.buildHeaders(),
+            body: options?.body ? JSON.stringify(options.body) : undefined,
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            let responseBody;
+            try {
+                responseBody = await response.json();
+            }
+            catch (e) {
+                process.stderr.write(`[tasks-adapter] response body read failed: ${e instanceof Error ? e.message : String(e)}\n`);
+                responseBody = await response.text().catch(() => undefined);
+            }
+            throw new ServerBackendError(`Server responded with ${response.status}: ${responseBody?.error ?? response.statusText}`, response.status, responseBody);
+        }
+        return await response.json();
+    }
+    async submitBreakpoint(params) {
+        if (params.proven) {
+            throw new ServerBackendError(unsupportedFeatureMessage(this.name, "ask_breakpoint.proven"), 400);
+        }
+        const projectId = params.projectId ?? this.projectId;
+        const repoId = params.repoId ?? this.repoId;
+        if (!projectId) {
+            throw new ServerBackendError("projectId is required for server backend", 400);
+        }
+        if (!repoId) {
+            throw new ServerBackendError("repoId is required for server backend", 400);
+        }
+        const body = {
+            text: params.text,
+            context: params.context,
+            routing: {
+                strategy: params.routing.strategy,
+                targetExperts: params.routing.targetResponders,
+                timeoutMs: params.routing.timeoutMs,
+                presentToUser: params.routing.presentToUser,
+            },
+            projectId,
+            repoId,
+        };
+        const question = await this.request("POST", `${API_BASE_PATH}/questions`, { body });
+        return mapServerQuestionToBreakpoint(question);
+    }
+    async getBreakpoint(id) {
+        const question = await this.request("GET", `${API_BASE_PATH}/questions/${encodeURIComponent(id)}`);
+        return mapServerQuestionToBreakpoint(question);
+    }
+    async waitForAnswer(id, options) {
+        const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const pollIntervalMs = options?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        const startTime = Date.now();
+        const TIMEOUT_SENTINEL = Symbol("timeout");
+        const abortController = new AbortController();
+        const externalSignal = options?.signal;
+        if (externalSignal) {
+            if (externalSignal.aborted) {
+                abortController.abort(externalSignal.reason);
+            }
+            else {
+                externalSignal.addEventListener("abort", () => {
+                    abortController.abort(externalSignal.reason);
+                }, { once: true });
+            }
+        }
+        const timeoutId = setTimeout(() => {
+            abortController.abort(TIMEOUT_SENTINEL);
+        }, timeoutMs);
+        try {
+            while (!abortController.signal.aborted) {
+                const breakpoint = await this.getBreakpoint(id);
+                const elapsedMs = Date.now() - startTime;
+                if (breakpoint.answers.length > 0) {
+                    const selectedAnswer = breakpoint.selectedAnswer
+                        ? breakpoint.answers.find((a) => a.id === breakpoint.selectedAnswer)
+                        : breakpoint.answers[0];
+                    return {
+                        answered: true,
+                        breakpoint,
+                        answer: selectedAnswer,
+                        allAnswers: breakpoint.answers,
+                        resolution: "answered",
+                        elapsedMs,
+                    };
+                }
+                if (breakpoint.status === "cancelled" || breakpoint.status === "expired") {
+                    return {
+                        answered: false,
+                        breakpoint,
+                        allAnswers: [],
+                        resolution: breakpoint.status,
+                        elapsedMs,
+                    };
+                }
+                const aborted = await new Promise((resolve) => {
+                    const pollTimeout = setTimeout(() => resolve(false), pollIntervalMs);
+                    if (abortController.signal.aborted) {
+                        clearTimeout(pollTimeout);
+                        resolve(true);
+                        return;
+                    }
+                    abortController.signal.addEventListener("abort", () => {
+                        clearTimeout(pollTimeout);
+                        resolve(true);
+                    }, { once: true });
+                });
+                if (aborted)
+                    break;
+            }
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        const breakpoint = await this.getBreakpoint(id);
+        const isTimeout = abortController.signal.reason === TIMEOUT_SENTINEL;
+        return {
+            answered: false,
+            breakpoint,
+            allAnswers: breakpoint.answers,
+            resolution: isTimeout ? "timeout" : "aborted",
+            elapsedMs: Date.now() - startTime,
+        };
+    }
+    async listPendingBreakpoints(responderId) {
+        if (!this.projectId) {
+            throw new ServerBackendError("projectId is required to list pending breakpoints", 400);
+        }
+        if (responderId) {
+            const questions = await this.request("GET", `${API_BASE_PATH}/experts/${encodeURIComponent(responderId)}/questions`, {
+                params: {
+                    status: "routed",
+                    projectId: this.projectId,
+                    repoId: this.repoId,
+                },
+            });
+            return questions.map(mapServerQuestionToBreakpoint);
+        }
+        const questions = await this.request("GET", `${API_BASE_PATH}/questions`, {
+            params: {
+                status: "pending",
+                projectId: this.projectId,
+                repoId: this.repoId,
+            },
+        });
+        return questions.map(mapServerQuestionToBreakpoint);
+    }
+    async answerBreakpoint(id, answer) {
+        if (answer.sign || answer.keyFingerprint) {
+            throw new ServerBackendError(unsupportedFeatureMessage(this.name, "answer signing"), 400);
+        }
+        const body = {
+            expertId: answer.responderId,
+            expertName: answer.responderName,
+            text: answer.text,
+            approved: answer.approved,
+            confidence: answer.confidence ?? 80,
+            references: answer.references ?? [],
+            followUpQuestions: answer.followUpQuestions ?? [],
+            decisionMemory: answer.decisionMemory,
+        };
+        const serverAnswer = await this.request("POST", `${API_BASE_PATH}/questions/${encodeURIComponent(id)}/answers`, { body });
+        return mapServerAnswerToBreakpointAnswer(serverAnswer);
+    }
+    async cancelBreakpoint(id) {
+        await this.request("DELETE", `${API_BASE_PATH}/questions/${encodeURIComponent(id)}`);
+    }
+    async listResponders(params) {
+        const projectId = params?.projectId ?? this.projectId;
+        const repoId = params?.repoId ?? this.repoId;
+        const experts = await this.request("GET", `${API_BASE_PATH}/experts`, {
+            params: {
+                projectId,
+                repoId,
+            },
+        });
+        return experts.map(mapExpertProfileToResponderProfile);
+    }
+    async claimBreakpoint(id, responderId) {
+        const body = {
+            expertId: responderId,
+        };
+        const question = await this.request("POST", `${API_BASE_PATH}/questions/${encodeURIComponent(id)}/claim`, { body });
+        return mapServerQuestionToBreakpoint(question);
+    }
+}

package/dist/cli/auth-store.d.ts

@@ -0,0 +1,49 @@
+import { type AuthToken } from "../auth/index.js";
+export interface BmuxClientConfig {
+    serverUrl?: string;
+    authToken?: string;
+}
+/**
+ * Get the path to the tasks-adapter config directory (~/.tasks-adapter).
+ */
+export declare function getBmuxDir(): string;
+/**
+ * Get the path to the auth state file (~/.tasks-adapter/auth.json).
+ */
+export declare function getAuthStorePath(): string;
+/**
+ * Get the path to the client config file (~/.tasks-adapter/config.json).
+ */
+export declare function getClientConfigPath(): string;
+/**
+ * Get the path to the SSH keys directory (~/.tasks-adapter/keys).
+ */
+export declare function getKeysDir(): string;
+/**
+ * Load CLI/MCP client configuration from ~/.tasks-adapter/config.json.
+ */
+export declare function loadClientConfig(): BmuxClientConfig;
+/**
+ * Save or update CLI/MCP client configuration in ~/.tasks-adapter/config.json.
+ */
+export declare function saveClientConfig(next: BmuxClientConfig): void;
+/**
+ * Load the stored authentication state from ~/.tasks-adapter/auth.json.
+ * Returns null if no auth file exists or the contents are invalid.
+ */
+export declare function loadAuthState(): AuthToken | null;
+/**
+ * Save authentication state to ~/.tasks-adapter/auth.json.
+ * Creates the directory if it does not exist.
+ * Sets file permissions to 0600 (owner read/write only).
+ */
+export declare function saveAuthState(state: AuthToken): void;
+/**
+ * Clear the stored authentication state by removing ~/.tasks-adapter/auth.json.
+ */
+export declare function clearAuthState(): void;
+/**
+ * Check whether a token has expired based on its expiresAt timestamp.
+ */
+export declare function isTokenExpired(expiresAt: string): boolean;
+//# sourceMappingURL=auth-store.d.ts.map

package/dist/cli/auth-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-store.d.ts","sourceRoot":"","sources":["../../src/cli/auth-store.ts"],"names":[],"mappings":"AAGA,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AASnE,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAID;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,gBAAgB,CAuBnD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAoC7D;AAID;;;GAGG;AACH,wBAAgB,aAAa,IAAI,SAAS,GAAG,IAAI,CAoBhD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CASpD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAMrC;AAID;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAGzD"}