@onesi/genesis 0.0.1-stage → 0.2.0

package/dist/runner-grant.js

@@ -0,0 +1,133 @@
+import { GenesisError } from './errors.js';
+export const RUNNER_SELF_GRANT_OPERATION = 'iam_runnerSelfExecutionGrant';
+const requestKeys = ['schemaVersion', 'requestId', 'operationId', 'organizationId', 'projectId', 'platformId', 'workspaceId', 'fleetId', 'resourceEnvironment', 'expiresAtMs'];
+const receiptKeys = ['id', 'principal_id', 'organization_id', 'project_id', 'platform_id', 'workspace_id', 'environmentId', 'role_ids', 'permissions', 'expires_at', 'created_at'];
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const match = (p, v) => typeof v === 'string' && p.exec(v)?.[0] === v;
+const native = (v, prefix) => match(new RegExp('^' + prefix + '[A-Za-z0-9_]{1,32}$'), v);
+const instant = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+function exact(v, keys) {
+    return !!v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === keys.length && keys.every(k => Object.hasOwn(v, k));
+}
+const invalid = () => new TypeError('Runner self-execution permission requires the exact ordinary-human Sandbox selection, operation, request correlation and finite expiry');
+/** Copy only primitive data descriptors before any asynchronous credential call. */
+export function snapshotRunnerSelfGrant(args, routing) {
+    if (routing !== 'gateway' || !exact(args, ['body']) || Reflect.ownKeys(args).length !== 1)
+        throw invalid();
+    const descriptor = Object.getOwnPropertyDescriptor(args, 'body');
+    if (!descriptor || !('value' in descriptor))
+        throw invalid();
+    const body = descriptor.value;
+    if (!exact(body, requestKeys) || ![Object.prototype, null].includes(Object.getPrototypeOf(body)) || Reflect.ownKeys(body).length !== requestKeys.length)
+        throw invalid();
+    const copy = {};
+    for (const key of requestKeys) {
+        const d = Object.getOwnPropertyDescriptor(body, key);
+        if (!d || !('value' in d) || !d.enumerable || (d.value !== null && !['string', 'number'].includes(typeof d.value)))
+            throw invalid();
+        copy[key] = d.value;
+    }
+    const now = Date.now();
+    if (copy.schemaVersion !== 1 || !match(uuid, copy.requestId) || !match(uuid, copy.operationId)
+        || !native(copy.organizationId, 'o_') || !native(copy.projectId, 'pr_') || !native(copy.workspaceId, 'w_')
+        || copy.platformId !== 'pf_console' || copy.fleetId !== null || copy.resourceEnvironment !== 'sandbox'
+        || !instant(copy.expiresAtMs) || copy.expiresAtMs <= now || copy.expiresAtMs > now + 1_800_000)
+        throw invalid();
+    return Object.freeze(copy);
+}
+function closedJson(raw) {
+    const value = JSON.parse(raw);
+    const stack = [];
+    for (const token of raw.match(/"(?:\\.|[^"\\])*"|[{}\[\],:]|true|false|null|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g) ?? []) {
+        const frame = stack.at(-1);
+        if (token === '{' || token === '[')
+            stack.push({ object: token === '{', key: token === '{', keys: new Set() });
+        else if (token === '}' || token === ']')
+            stack.pop();
+        else if (token === ',' && frame?.object)
+            frame.key = true;
+        else if (token === ':' && frame?.object)
+            frame.key = false;
+        else if (token.startsWith('"') && frame?.object && frame.key) {
+            const key = JSON.parse(token);
+            if (frame.keys.has(key))
+                throw invalid();
+            frame.keys.add(key);
+        }
+        else if (/^-?\d/.test(token) && !/^-?(?:0|[1-9]\d*)$/.test(token))
+            throw invalid();
+    }
+    return value;
+}
+const errorRows = [
+    [400, 'INVALID_ARGUMENT', 'invalid Runner self-execution grant request', 'invalid_runner_self_execution_grant_request'],
+    [400, 'INVALID_ARGUMENT', 'Runner self-execution grant expiry is out of bounds', 'runner_self_execution_grant_expiry_out_of_bounds'],
+    [401, 'UNAUTHENTICATED', 'Runner self-execution authority inactive', 'runner_self_execution_grant_inactive'],
+    [403, 'PERMISSION_DENIED', 'Runner self-execution authority denied', 'runner_self_execution_grant_denied'],
+    [409, 'CONFLICT', 'Runner self-execution grant operation conflict', 'runner_self_execution_grant_conflict'],
+    [409, 'CONFLICT', 'Runner self-execution grant replay is stale', 'runner_self_execution_grant_replay_stale'],
+    [503, 'PROVIDER_UNAVAILABLE', 'Runner self-execution grant unavailable', 'runner_self_execution_grant_unavailable'],
+];
+function uncertain(status, message) {
+    return new GenesisError({ status, type: 'runner_grant_uncertain', operationId: RUNNER_SELF_GRANT_OPERATION, message });
+}
+export function runnerGrantTransportError() {
+    return uncertain(0, 'Runner permission response was lost. Retry the same operation, scope and expiry with fresh request correlation.');
+}
+/** A bounded closed response; no arbitrary upstream body reaches CLI or MCP. */
+export async function runnerGrantResponse(res, input) {
+    let value;
+    try {
+        if (res.redirected || res.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== 'application/json')
+            throw invalid();
+        const reader = res.body?.getReader();
+        const chunks = [];
+        let size = 0;
+        if (reader) {
+            try {
+                while (true) {
+                    const next = await reader.read();
+                    if (next.done)
+                        break;
+                    size += next.value.byteLength;
+                    if (size > 8192) {
+                        await reader.cancel();
+                        throw invalid();
+                    }
+                    chunks.push(next.value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        const bytes = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        value = closedJson(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw uncertain(res.status, 'Runner permission could not be confirmed. Retry the same operation, scope and expiry with fresh request correlation.');
+    }
+    if (res.status !== 200) {
+        if (exact(value, ['code', 'message', 'details']) && exact(value.details, ['schemaVersion', 'reason']) && value.details.schemaVersion === 1) {
+            const details = value.details;
+            const row = errorRows.find(r => r[0] === res.status && r[1] === value.code && r[2] === value.message && r[3] === details.reason);
+            if (row)
+                throw new GenesisError({ status: res.status, type: 'runner_grant_denied', code: row[1], operationId: RUNNER_SELF_GRANT_OPERATION, message: row[2], body: value });
+        }
+        throw uncertain(res.status, 'Runner permission is unavailable or unconfirmed. Retry the same operation, scope and expiry with fresh request correlation.');
+    }
+    if (!exact(value, receiptKeys) || !match(/^g_[0-7][0123456789ABCDEFGHJKMNPQRSTVWXYZ]{25}$/, value.id)
+        || !native(value.principal_id, 'h_') || value.organization_id !== input.organizationId || value.project_id !== input.projectId
+        || value.platform_id !== input.platformId || value.workspace_id !== input.workspaceId || value.environmentId !== input.resourceEnvironment
+        || !Array.isArray(value.role_ids) || value.role_ids.length !== 0 || !Array.isArray(value.permissions)
+        || value.permissions.length !== 1 || value.permissions[0] !== 'runner.tasks.execute'
+        || value.expires_at !== input.expiresAtMs || input.expiresAtMs <= Date.now() || !instant(value.created_at) || value.created_at >= input.expiresAtMs) {
+        throw uncertain(502, 'Runner returned an unqualified permission receipt. Retry the same operation, scope and expiry to reconcile it.');
+    }
+    return Response.json(value, { status: 200, headers: { 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' } });
+}

package/dist/runner.d.ts

@@ -0,0 +1,72 @@
+import type { GenesisClient } from './client.js';
+import type { components } from './generated/schema.js';
+import { type RunnerSelfExecutionGrantInput } from './runner-grant.js';
+type Schemas = components['schemas'];
+export type RunnerStartInput = Schemas['Runner.StartInput'];
+export type RunnerSnapshot = Schemas['Runner.Snapshot'];
+export type RunnerCatalog = Schemas['Runner.Catalog'];
+export type RunnerEvent = Schemas['Runner.Event'];
+export type RunnerProviderResult = Schemas['Runner.ProviderResult'];
+export type RunnerRequestOptions = {
+    signal?: AbortSignal;
+};
+/** Runner routes use the Genesis client's credential; the backend owns org/subject scoping. */
+export declare function runnerModule(client: GenesisClient): Readonly<{
+    permission: Readonly<{
+        grant: (input: RunnerSelfExecutionGrantInput, opts?: RunnerRequestOptions) => Promise<{
+            id: string;
+            principal_id: string;
+            organization_id: string;
+            project_id: string;
+            platform_id: "pf_console";
+            workspace_id: string;
+            environmentId: "sandbox";
+            role_ids: unknown[];
+            permissions: "runner.tasks.execute"[];
+            expires_at: number;
+            created_at: number;
+        }>;
+    }>;
+    catalog: (opts?: RunnerRequestOptions) => Promise<{
+        workspaces: {
+            key: components["schemas"]["Runner.SafeOpaqueRef"];
+            label: string;
+        }[];
+        routes: {
+            routeId: components["schemas"]["Runner.SafeOpaqueRef"];
+            kind: "external-harness" | "internal-model";
+            name: string;
+            via: string;
+            state: "synthetic" | "bound" | "unbound";
+            default: boolean;
+        }[];
+    }>;
+    jobs: Readonly<{
+        list: (opts?: RunnerRequestOptions) => Promise<{
+            jobs: components["schemas"]["Runner.Snapshot"][];
+        }>;
+        start: (input: RunnerStartInput, opts?: RunnerRequestOptions) => Promise<{
+            jobId: components["schemas"]["Runner.SafeOpaqueRef"];
+            snapshot: components["schemas"]["Runner.Snapshot"];
+        }>;
+        get: (jobId: string, opts?: RunnerRequestOptions) => Promise<{
+            snapshot: components["schemas"]["Runner.Snapshot"];
+        }>;
+        events: (jobId: string, afterSeq?: number, opts?: RunnerRequestOptions) => Promise<{
+            events: components["schemas"]["Runner.Event"][];
+            nextAfterSeq: number;
+            hasMore: boolean;
+        }>;
+        result: (jobId: string, opts?: RunnerRequestOptions) => Promise<{
+            result: components["schemas"]["Runner.ProviderResult"];
+        }>;
+        cancel: (jobId: string, opts?: RunnerRequestOptions) => Promise<{
+            snapshot: components["schemas"]["Runner.Snapshot"];
+        }>;
+        delete: (jobId: string, opts?: RunnerRequestOptions) => Promise<{
+            jobId: components["schemas"]["Runner.SafeOpaqueRef"];
+            deleted: true;
+        }>;
+    }>;
+}>;
+export {};

package/dist/runner.js

@@ -0,0 +1,117 @@
+import { RUNNER_SELF_GRANT_OPERATION } from './runner-grant.js';
+const requestOptions = (options) => ({ signal: options.signal });
+const opaqueId = (v) => typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(v);
+const pathLike = (v) => /^[A-Za-z]:/.test(v) || v.includes('..');
+const invalid = () => new TypeError('Runner input must match the bounded runner/task-client/v0 contract');
+function checkedJobId(value) {
+    if (!opaqueId(value) || pathLike(value)
+        || /^(?:https?|ftp|file|data|javascript|bearer|basic):|^(?:sk[-_]|pk[-_]|gh[pousr]_|github_pat_|xox[baprs]-|eyJ)/i.test(value)) {
+        throw invalid();
+    }
+    return value;
+}
+function closed(value, required, optional = []) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        && required.every((key) => Object.hasOwn(value, key))
+        && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+}
+// Match the core's input bounds and copy once so a caller cannot mutate a validated request
+// while the asynchronous credential provider runs. Identity is never an input property.
+function copyBoundedInput(value) {
+    let nodes = 0;
+    let chars = 0;
+    const ancestors = new Set();
+    const countText = (text) => {
+        chars += text.length;
+        if (text.length > 32768 || chars > 65536)
+            throw invalid();
+        return text;
+    };
+    const walk = (v, depth) => {
+        if (++nodes > 256)
+            throw invalid();
+        if (v === null || typeof v === 'boolean')
+            return v;
+        if (typeof v === 'string')
+            return countText(v);
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v !== 'object' || depth >= 6 || ancestors.has(v))
+            throw invalid();
+        ancestors.add(v);
+        try {
+            if (Array.isArray(v)) {
+                if (Object.getPrototypeOf(v) !== Array.prototype || v.length > 64 || Reflect.ownKeys(v).length !== v.length + 1)
+                    throw invalid();
+                return Array.from({ length: v.length }, (_, index) => {
+                    const d = Object.getOwnPropertyDescriptor(v, String(index));
+                    if (!d || !('value' in d) || !d.enumerable)
+                        throw invalid();
+                    return walk(d.value, depth + 1);
+                });
+            }
+            const prototype = Object.getPrototypeOf(v);
+            if (prototype !== null && prototype !== Object.prototype)
+                throw invalid();
+            const keys = Reflect.ownKeys(v);
+            if (keys.length > 32)
+                throw invalid();
+            const out = Object.create(null);
+            for (const key of keys) {
+                if (typeof key !== 'string')
+                    throw invalid();
+                countText(key);
+                const d = Object.getOwnPropertyDescriptor(v, key);
+                if (!('value' in d) || !d.enumerable)
+                    throw invalid();
+                out[key] = walk(d.value, depth + 1);
+            }
+            return out;
+        }
+        finally {
+            ancestors.delete(v);
+        }
+    };
+    return walk(value, 0);
+}
+function checkedStartInput(input) {
+    const v = copyBoundedInput(input);
+    if (!closed(v, ['task', 'workspaceRef', 'executionRef', 'limits', 'idempotencyKey'])
+        || !closed(v.task, ['id', 'text'], ['meta']) || !opaqueId(v.task.id)
+        || typeof v.task.text !== 'string' || !v.task.text.trim()
+        || (Object.hasOwn(v.task, 'meta') && (v.task.meta === null || typeof v.task.meta !== 'object' || Array.isArray(v.task.meta)))
+        || !opaqueId(v.workspaceRef) || pathLike(v.workspaceRef)
+        || !closed(v.executionRef, ['kind', 'routeId'])
+        || !['external-harness', 'internal-model'].includes(v.executionRef.kind) || !opaqueId(v.executionRef.routeId)
+        || !closed(v.limits, ['maxDurationMs', 'maxOutputBytes'], ['maxEvents']) || !opaqueId(v.idempotencyKey))
+        throw invalid();
+    const limit = (n, maximum) => Number.isInteger(n) && n > 0 && n <= maximum;
+    if (!limit(v.limits.maxDurationMs, 86400000) || !limit(v.limits.maxOutputBytes, 67108864)
+        || (Object.hasOwn(v.limits, 'maxEvents') && !limit(v.limits.maxEvents, 1000)))
+        throw invalid();
+    if (new TextEncoder().encode(JSON.stringify(v)).byteLength > 65536)
+        throw invalid();
+    return v;
+}
+/** Runner routes use the Genesis client's credential; the backend owns org/subject scoping. */
+export function runnerModule(client) {
+    return Object.freeze({
+        permission: Object.freeze({
+            grant: (input, opts = {}) => client.request(RUNNER_SELF_GRANT_OPERATION, { body: input }, requestOptions(opts)),
+        }),
+        catalog: (opts = {}) => client.request('runner_getCatalog', undefined, requestOptions(opts)),
+        jobs: Object.freeze({
+            list: (opts = {}) => client.request('runner_listJobs', undefined, requestOptions(opts)),
+            start: (input, opts = {}) => client.request('runner_startJob', { body: checkedStartInput(input) }, requestOptions(opts)),
+            get: (jobId, opts = {}) => client.request('runner_getJob', { jobId: checkedJobId(jobId) }, requestOptions(opts)),
+            events: (jobId, afterSeq = 0, opts = {}) => {
+                if (!Number.isSafeInteger(afterSeq) || afterSeq < 0)
+                    throw invalid();
+                return client.request('runner_getJobEvents', { jobId: checkedJobId(jobId), afterSeq }, requestOptions(opts));
+            },
+            result: (jobId, opts = {}) => client.request('runner_getJobResult', { jobId: checkedJobId(jobId) }, requestOptions(opts)),
+            cancel: (jobId, opts = {}) => client.request('runner_cancelJob', { jobId: checkedJobId(jobId) }, requestOptions(opts)),
+            delete: (jobId, opts = {}) => client.request('runner_deleteJob', { jobId: checkedJobId(jobId) }, requestOptions(opts)),
+        }),
+    });
+}

package/dist/scopes.d.ts

@@ -0,0 +1,310 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Scopes (work graph): projects, tasks, dependencies, assignments to agents or people, comments and activity.
+ * Scopes never runs agents; the assignee's runtime (Henry, Fleets or Flocks) does. Updates, archives and assignee
+ * changes take the `version` you read (sent as If-Match); a stale one is a 409. Archiving needs scopes:admin. */
+export declare function scopesModule(client: GenesisClient): {
+    whoami: () => Promise<{
+        org: string;
+        principal: string;
+        kind: "api_key" | "m2m_token" | "bridge_session";
+        scopes: string[];
+    }>;
+    workload: (projectId?: string) => Promise<{
+        data: import("./index.js").components["schemas"]["Scopes.Workload"][];
+    }>;
+    projects: {
+        list: (filter?: In<"scopes_listProjects">) => Promise<{
+            data: import("./index.js").components["schemas"]["Scopes.Project"][];
+        }>;
+        get: (project: string) => Promise<{
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.ProjectStatus"];
+            auto_org_id: string | null;
+            lead: string | null;
+            target_on: string | null;
+            task_count: number;
+            open_count: number;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        create: (body: In<"scopes_createProject">["body"]) => Promise<{
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.ProjectStatus"];
+            auto_org_id: string | null;
+            lead: string | null;
+            target_on: string | null;
+            task_count: number;
+            open_count: number;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        update: (project: string, version: number | string, body: In<"scopes_updateProject">["body"]) => Promise<{
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.ProjectStatus"];
+            auto_org_id: string | null;
+            lead: string | null;
+            target_on: string | null;
+            task_count: number;
+            open_count: number;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        archive: (project: string, version: number | string) => Promise<{
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.ProjectStatus"];
+            auto_org_id: string | null;
+            lead: string | null;
+            target_on: string | null;
+            task_count: number;
+            open_count: number;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        graph: (project: string) => Promise<{
+            project: import("./index.js").components["schemas"]["Scopes.Project"];
+            tasks: import("./index.js").components["schemas"]["Scopes.Task"][];
+            edges: {
+                from: string;
+                to: string;
+                kind: import("./index.js").components["schemas"]["Scopes.DependencyKind"];
+            }[];
+            order: string[];
+            critical_path: string[];
+        }>;
+        ready: (project: string, unassigned?: boolean) => Promise<{
+            data: import("./index.js").components["schemas"]["Scopes.Task"][];
+        }>;
+        tasks: (project: string, filter?: Omit<In<"scopes_listProjectTasks">, "project">) => Promise<{
+            data: import("./index.js").components["schemas"]["Scopes.Task"][];
+            next_after: number | null;
+        }>;
+        createTask: (project: string, body: In<"scopes_createTask">["body"]) => Promise<{
+            id: string;
+            project_id: string;
+            number: number;
+            identifier: string;
+            title: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.TaskStatus"];
+            priority: import("./index.js").components["schemas"]["Scopes.Priority"];
+            estimate: number | null;
+            labels: string[];
+            parent_id: string | null;
+            due_on: string | null;
+            start_on: string | null;
+            assignee: import("./index.js").components["schemas"]["Scopes.Assignee"] | null;
+            assigned_at: string | null;
+            started_at: string | null;
+            completed_at: string | null;
+            canceled_at: string | null;
+            blocked: boolean;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        activity: (project: string, p?: {
+            after?: number;
+            limit?: number;
+        }) => Promise<{
+            data: import("./index.js").components["schemas"]["Scopes.Event"][];
+            next_after: number | null;
+        }>;
+    };
+    tasks: {
+        list: (filter?: In<"scopes_listTasks">) => Promise<{
+            data: import("./index.js").components["schemas"]["Scopes.Task"][];
+            next_after: number | null;
+        }>;
+        get: (task: string) => Promise<{
+            id: string;
+            project_id: string;
+            number: number;
+            identifier: string;
+            title: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.TaskStatus"];
+            priority: import("./index.js").components["schemas"]["Scopes.Priority"];
+            estimate: number | null;
+            labels: string[];
+            parent_id: string | null;
+            due_on: string | null;
+            start_on: string | null;
+            assignee: import("./index.js").components["schemas"]["Scopes.Assignee"] | null;
+            assigned_at: string | null;
+            started_at: string | null;
+            completed_at: string | null;
+            canceled_at: string | null;
+            blocked: boolean;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        update: (task: string, version: number | string, body: In<"scopes_updateTask">["body"]) => Promise<{
+            id: string;
+            project_id: string;
+            number: number;
+            identifier: string;
+            title: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.TaskStatus"];
+            priority: import("./index.js").components["schemas"]["Scopes.Priority"];
+            estimate: number | null;
+            labels: string[];
+            parent_id: string | null;
+            due_on: string | null;
+            start_on: string | null;
+            assignee: import("./index.js").components["schemas"]["Scopes.Assignee"] | null;
+            assigned_at: string | null;
+            started_at: string | null;
+            completed_at: string | null;
+            canceled_at: string | null;
+            blocked: boolean;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        archive: (task: string, version: number | string) => Promise<{
+            id: string;
+            project_id: string;
+            number: number;
+            identifier: string;
+            title: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.TaskStatus"];
+            priority: import("./index.js").components["schemas"]["Scopes.Priority"];
+            estimate: number | null;
+            labels: string[];
+            parent_id: string | null;
+            due_on: string | null;
+            start_on: string | null;
+            assignee: import("./index.js").components["schemas"]["Scopes.Assignee"] | null;
+            assigned_at: string | null;
+            started_at: string | null;
+            completed_at: string | null;
+            canceled_at: string | null;
+            blocked: boolean;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        assign: (task: string, version: number | string, body: In<"scopes_assignTask">["body"]) => Promise<{
+            id: string;
+            project_id: string;
+            number: number;
+            identifier: string;
+            title: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.TaskStatus"];
+            priority: import("./index.js").components["schemas"]["Scopes.Priority"];
+            estimate: number | null;
+            labels: string[];
+            parent_id: string | null;
+            due_on: string | null;
+            start_on: string | null;
+            assignee: import("./index.js").components["schemas"]["Scopes.Assignee"] | null;
+            assigned_at: string | null;
+            started_at: string | null;
+            completed_at: string | null;
+            canceled_at: string | null;
+            blocked: boolean;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        unassign: (task: string, version: number | string) => Promise<{
+            id: string;
+            project_id: string;
+            number: number;
+            identifier: string;
+            title: string;
+            description: string | null;
+            status: import("./index.js").components["schemas"]["Scopes.TaskStatus"];
+            priority: import("./index.js").components["schemas"]["Scopes.Priority"];
+            estimate: number | null;
+            labels: string[];
+            parent_id: string | null;
+            due_on: string | null;
+            start_on: string | null;
+            assignee: import("./index.js").components["schemas"]["Scopes.Assignee"] | null;
+            assigned_at: string | null;
+            started_at: string | null;
+            completed_at: string | null;
+            canceled_at: string | null;
+            blocked: boolean;
+            archived_at: string | null;
+            version: number;
+            created_at: string;
+            updated_at: string;
+        }>;
+        assignments: (task: string) => Promise<{
+            data: import("./index.js").components["schemas"]["Scopes.Assignment"][];
+        }>;
+        dependencies: (task: string) => Promise<{
+            blocked_by: import("./index.js").components["schemas"]["Scopes.Dependency"][];
+            blocks: import("./index.js").components["schemas"]["Scopes.Dependency"][];
+            related: import("./index.js").components["schemas"]["Scopes.Dependency"][];
+        }>;
+        addDependency: (task: string, body: In<"scopes_addDependency">["body"]) => Promise<{
+            id: string;
+            task_id: string;
+            depends_on_id: string;
+            kind: import("./index.js").components["schemas"]["Scopes.DependencyKind"];
+            created_at: string;
+            created_by: string;
+        }>;
+        comments: (task: string) => Promise<{
+            data: import("./index.js").components["schemas"]["Scopes.Comment"][];
+        }>;
+        addComment: (task: string, body: In<"scopes_addComment">["body"]) => Promise<{
+            id: string;
+            task_id: string;
+            body: string;
+            author: string;
+            author_kind: string;
+            created_at: string;
+        }>;
+        activity: (task: string, p?: {
+            after?: number;
+            limit?: number;
+        }) => Promise<{
+            data: import("./index.js").components["schemas"]["Scopes.Event"][];
+            next_after: number | null;
+        }>;
+    };
+    dependencies: {
+        remove: (dependency: string) => Promise<{
+            id: string;
+            task_id: string;
+            depends_on_id: string;
+            kind: import("./index.js").components["schemas"]["Scopes.DependencyKind"];
+            created_at: string;
+            created_by: string;
+        }>;
+    };
+};