@xenosystem/agent-interface-core 0.1.3

package/dist/fleetBoardProjection.js

@@ -0,0 +1,156 @@
+/**
+ * What a fleet surface may SHOW — ADE §9 step 6, the presentation half.
+ *
+ * `fleet.view` answers what the host knows. This decides what a person is told,
+ * and in what order. Pure, in `core`, for the same reason `reviewProjection`
+ * is: every rule here is about honesty rather than layout, and an honesty rule
+ * written in JSX is enforced by whoever writes the next component.
+ *
+ * ## 🔴 The board is ordered by what needs a human, not by name
+ *
+ * A fleet view exists to answer one question — *where do I need to look?* Sorted
+ * alphabetically it answers a different, useless one. So rows are ranked by
+ * attention: a run blocked on a live collision first, then one whose changes
+ * another run also touched, then one whose diff has a hole, then whatever is
+ * merely working.
+ *
+ * Ties break on run id so the order is STABLE. A board that reshuffles between
+ * polls is unusable for the thing a board is for — noticing what changed.
+ *
+ * ## Unobserved is its own status
+ *
+ * `diffComplete` is absent when nobody watched a run, and that is a third state
+ * beside complete and incomplete. Folding it into either lies in a different
+ * direction each way: "complete" claims a diff nobody collected, "incomplete"
+ * sends someone to fix an observation problem that does not exist.
+ */
+/**
+ * Why a run is at the top of the board, or that it is not.
+ *
+ * Ordered by urgency, and the numbers are deliberate: the projection sorts on
+ * them, so adding a status between two others is a one-line change rather than
+ * a re-reading of a comparator.
+ */
+export const FLEET_ATTENTION = {
+    /**
+     * 🔴 ABOVE `blocked`, deliberately.
+     *
+     * Both are stopped, but only one of them the reader can clear. A path
+     * collision waits on another RUN finishing; a permission prompt waits on the
+     * person looking at this board, and every second it sits below something they
+     * cannot act on is a second of nothing happening for no reason.
+     */
+    'awaiting-approval': 0,
+    blocked: 1,
+    contested: 2,
+    incomplete: 3,
+    working: 4,
+    unobserved: 5,
+    idle: 6,
+};
+export function projectFleetBoard(input) {
+    const blockedRuns = new Set();
+    for (const collision of input.collisions) {
+        // The run that WANTED the scope is the blocked one. The holder is working
+        // normally and has no idea it is in anyone's way.
+        if (collision.stillHeld)
+            blockedRuns.add(collision.wantedByRunId);
+    }
+    const rows = input.runs.map((run) => {
+        const attention = attentionFor(run, blockedRuns.has(run.runId));
+        return {
+            runId: run.runId,
+            attention,
+            ...(run.heldMessages === undefined ? {} : { heldMessages: run.heldMessages }),
+            ...(run.inboundPolicy === undefined ? {} : { inboundPolicy: run.inboundPolicy }),
+            ...(run.isolation === undefined ? {} : { isolation: run.isolation }),
+            ...(run.isolationMechanism === undefined ? {} : { isolationMechanism: run.isolationMechanism }),
+            working: run.working,
+            claims: run.claims,
+            contestedPaths: run.contestedPaths,
+            // Carried through rather than derived: the host owns provenance, and a
+            // projection that inferred an origin would be inventing one.
+            ...(run.intakeItemId ? { intakeItemId: run.intakeItemId } : {}),
+            ...(run.changes ? { changes: run.changes } : {}),
+            headline: headlineFor(run, attention),
+            // Only a diff explicitly reported complete may be trusted. Absent means
+            // unobserved, which is not a diff at all.
+            diffTrustworthy: run.diffComplete === true,
+        };
+    });
+    rows.sort((left, right) => FLEET_ATTENTION[left.attention] === FLEET_ATTENTION[right.attention]
+        ? left.runId.localeCompare(right.runId)
+        : FLEET_ATTENTION[left.attention] - FLEET_ATTENTION[right.attention]);
+    const liveCollisions = input.collisions.filter((collision) => collision.stillHeld);
+    const resolvedCollisions = input.collisions.filter((collision) => !collision.stillHeld);
+    const trustworthy = input.coordinationComplete && input.observationComplete;
+    return {
+        rows,
+        liveCollisions,
+        resolvedCollisions,
+        ...(trustworthy ? {} : { notice: noticeFor(input) }),
+        trustworthy,
+    };
+}
+function attentionFor(run, blocked) {
+    // FIRST, above every other reason a run is stopped: this is the only one the
+    // reader can clear themselves, and `working` would otherwise swallow it — a
+    // turn blocked on a human is still in flight.
+    if (run.awaitingApproval === true)
+        return 'awaiting-approval';
+    if (blocked)
+        return 'blocked';
+    if (run.contestedPaths.length > 0)
+        return 'contested';
+    if (run.diffComplete === false)
+        return 'incomplete';
+    if (run.working)
+        return 'working';
+    // Checked AFTER `working`: a run that is executing right now is worth showing
+    // as working even though nothing is watching its filesystem. Ordering these
+    // the other way would bury every live run under a bookkeeping status.
+    if (run.diffComplete === undefined)
+        return 'unobserved';
+    return 'idle';
+}
+function headlineFor(run, attention) {
+    switch (attention) {
+        case 'awaiting-approval':
+            // Second person, because the reader is the one being waited on.
+            return 'Waiting for your approval.';
+        case 'blocked':
+            return 'Waiting on a path another run holds.';
+        case 'contested':
+            return run.contestedPaths.length === 1
+                ? `Also changed by another run: ${run.contestedPaths[0]}`
+                : `${run.contestedPaths.length} paths are also changed by another run.`;
+        case 'incomplete':
+            return 'Some of this run\'s changes were missed. Do not treat its diff as the whole story.';
+        case 'working':
+            return 'Working.';
+        case 'unobserved':
+            return 'Not observed, so there is no diff for this run.';
+        case 'idle':
+            return summariseChanges(run.changes);
+    }
+}
+function summariseChanges(changes) {
+    if (!changes)
+        return 'Idle.';
+    const total = changes.added + changes.modified + changes.deleted;
+    if (total === 0)
+        return 'Changed nothing.';
+    return `${changes.added} added, ${changes.modified} modified, ${changes.deleted} deleted.`;
+}
+function noticeFor(input) {
+    // The first problem, not all of them: a board is scanned, and a paragraph of
+    // caveats is skipped. The rest stay available on the runs themselves.
+    const first = input.problems[0];
+    if (!input.observationComplete) {
+        return first
+            ? `Some runs have gaps in what was observed: ${first}`
+            : 'Some runs have gaps in what was observed. Their diffs are not the whole story.';
+    }
+    return first ?? 'This board may not show everything.';
+}
+//# sourceMappingURL=fleetBoardProjection.js.map

package/dist/fleetBoardProjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleetBoardProjection.js","sourceRoot":"","sources":["../src/fleetBoardProjection.ts"],"names":[],"mappings":"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"}

package/dist/fleetProjection.d.ts

@@ -0,0 +1,63 @@
+import type { AgentRuntimeEventEnvelope } from '@xenosystem/agent-interface-contract';
+/**
+ * The fleet view — what is claimed, by whom, and where two runs collided.
+ *
+ * @unwired-by-design ADE §9 step 6 — the LIVE fleet view (`fleet.view`) shipped
+ * without this, and deliberately. It reads claims from the registry and records
+ * collisions from the coordination sink, because those are the only places the
+ * facts exist right now: `publishPersistedRuntimeEvent` does not add persisted
+ * events to the host's in-memory map, so a projection over that map reported
+ * nothing in any composition with a repository — which is every real one. This
+ * projection remains correct for the case it was written for and that has no
+ * consumer yet: reconstructing a fleet AFTER the fact from a durable timeline,
+ * where no service is holding anything. It needs a timeline reader, not a
+ * surface.
+ *
+ * `XENO_AGENT_COORDINATION_SPEC.md` §5: a claim is "advisory to the agent and
+ * **authoritative to the human**", and "the fleet view shows what is claimed by
+ * whom, which is the fastest way to see a collision before it becomes a merge."
+ *
+ * ## Why a projection over events rather than a read of live state
+ *
+ * `CoordinationService` already knows the current claim map, so exposing that
+ * would be simpler — and would only ever answer for *now*. Deriving the view
+ * from the runtime timeline instead means the same function serves a live fleet
+ * dashboard and a reviewer opening yesterday's run, which is the case §9 cares
+ * about: reconstructing why a diff looks the way it does, after the fact, when
+ * no service is holding anything.
+ *
+ * Pure and provider-neutral, matching `projectAgentToolCalls` in this package.
+ *
+ * ## Collisions are kept after they resolve
+ *
+ * A refusal is evidence two runs wanted the same work. Dropping it once the
+ * holder releases would erase exactly the record a reviewer needs when the merge
+ * turns out wrong — "nobody collided" and "a collision happened and was handled"
+ * are different histories. Each collision carries `stillHeld` so a live view can
+ * show what is urgent without the projection having to forget what happened.
+ */
+export interface FleetClaim {
+    scope: string;
+    runId: string;
+    claimId: string;
+    /** ISO timestamp of the acquiring event. */
+    acquiredAt: string;
+}
+export interface FleetCollision {
+    scope: string;
+    wantedByRunId: string;
+    heldByRunId: string;
+    at: string;
+    /** True while the holder still holds an overlapping claim. */
+    stillHeld: boolean;
+}
+export interface FleetView {
+    /** Live claims, newest first. */
+    claims: FleetClaim[];
+    /** Every recorded collision, newest first. */
+    collisions: FleetCollision[];
+    /** Runs that appear anywhere in the coordination record. */
+    runIds: string[];
+}
+export declare function projectFleetView(runtimeEvents: readonly AgentRuntimeEventEnvelope[]): FleetView;
+//# sourceMappingURL=fleetProjection.d.ts.map

package/dist/fleetProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleetProjection.d.ts","sourceRoot":"","sources":["../src/fleetProjection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAA;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,EAAE,EAAE,MAAM,CAAA;IACV,8DAA8D;IAC9D,SAAS,EAAE,OAAO,CAAA;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,iCAAiC;IACjC,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB,8CAA8C;IAC9C,UAAU,EAAE,cAAc,EAAE,CAAA;IAC5B,4DAA4D;IAC5D,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AAoBD,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,SAAS,yBAAyB,EAAE,GAClD,SAAS,CAwEX"}

package/dist/fleetProjection.js

@@ -0,0 +1,86 @@
+function text(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+/**
+ * Same containment rule as the claim registry: `src/` covers `src/app.ts`.
+ *
+ * Compared SEGMENT-wise so `src` cannot swallow `srcgen`. Duplicated here rather
+ * than imported because this package is provider-neutral and must not depend on
+ * the host — and the rule is four lines. ⚠️ If it changes in one place it must
+ * change in both; `fleetProjection.test.ts` pins the boundary case so a drift
+ * fails rather than silently reporting the wrong collisions.
+ */
+function overlaps(a, b) {
+    if (a === b)
+        return true;
+    return b.startsWith(`${a}/`) || a.startsWith(`${b}/`);
+}
+export function projectFleetView(runtimeEvents) {
+    const claims = new Map();
+    const collisions = [];
+    const runIds = new Set();
+    const seen = new Set();
+    const ordered = [...runtimeEvents].sort((left, right) => left.sequence === right.sequence
+        ? left.timestamp.localeCompare(right.timestamp)
+        : left.sequence - right.sequence);
+    for (const envelope of ordered) {
+        // Runtime events are at-least-once in some transports; a replayed acquire
+        // would otherwise show one claim twice and a replayed release could drop a
+        // claim that is still held.
+        if (seen.has(envelope.id))
+            continue;
+        seen.add(envelope.id);
+        const payload = envelope.event;
+        const runId = text(payload.runId);
+        switch (envelope.type) {
+            case 'coordination.claim.acquired': {
+                const scope = text(payload.scope);
+                const claimId = text(payload.claimId);
+                if (!scope || !claimId || !runId)
+                    continue;
+                runIds.add(runId);
+                claims.set(claimId, { scope, runId, claimId, acquiredAt: envelope.timestamp });
+                break;
+            }
+            case 'coordination.claim.refused': {
+                const scope = text(payload.scope);
+                const heldByRunId = text(payload.heldByRunId);
+                if (!scope || !heldByRunId || !runId)
+                    continue;
+                runIds.add(runId);
+                runIds.add(heldByRunId);
+                collisions.push({
+                    scope,
+                    wantedByRunId: runId,
+                    heldByRunId,
+                    at: envelope.timestamp,
+                    // Recomputed at the end: a release later in the stream must clear it.
+                    stillHeld: true,
+                });
+                break;
+            }
+            case 'coordination.claim.released': {
+                if (!runId)
+                    continue;
+                runIds.add(runId);
+                for (const [claimId, claim] of claims) {
+                    if (claim.runId === runId)
+                        claims.delete(claimId);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const live = [...claims.values()];
+    for (const collision of collisions) {
+        collision.stillHeld = live.some((claim) => claim.runId === collision.heldByRunId && overlaps(claim.scope, collision.scope));
+    }
+    return {
+        claims: live.sort((left, right) => right.acquiredAt.localeCompare(left.acquiredAt)),
+        collisions: collisions.sort((left, right) => right.at.localeCompare(left.at)),
+        runIds: [...runIds].sort(),
+    };
+}
+//# sourceMappingURL=fleetProjection.js.map

package/dist/fleetProjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleetProjection.js","sourceRoot":"","sources":["../src/fleetProjection.ts"],"names":[],"mappings":"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"}

package/dist/hostBackedCapabilities.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A provider may not advertise a capability the HOST does not have — §7.1.
+ *
+ * Most entries in `AGENT_HARNESS_CAPABILITIES` are facts about a provider: this
+ * agent can read files, that one streams. A few are not. Coordination between
+ * runs is a property of the HOST — whether a `CoordinationService` is mounted —
+ * and no provider can make it true by declaring it.
+ *
+ * 🔴 Today no adapter declares them, so nothing is currently wrong. This exists
+ * for the commit that changes that. When coordination tools land, someone will
+ * flip these to `available` in an adapter matrix, and the host they run on may
+ * still have no coordination service. The surface would then offer a claim map
+ * for a host that cannot answer, which is precisely the capability-honesty
+ * failure the matrix was introduced to prevent.
+ *
+ * ## Downgrade, not refuse
+ *
+ * A provider that over-claims is still useful for everything else it does, so
+ * refusing to register it would trade a small dishonesty for a total loss of the
+ * lane. The claim is lowered to `unsupported` with a reason naming the host as
+ * the source — `source: 'host'` is the honest attribution, because the provider
+ * did not decide this and a reader chasing the reason should look at the host.
+ */
+import type { AgentCapabilityMatrix } from '@xenosystem/agent-interface-contract';
+/**
+ * Capabilities whose truth is owned by the host, not the provider.
+ *
+ * Deliberately narrow. A capability belongs here only when NO provider
+ * implementation could make it true on a host that lacks the backing — which is
+ * why `background-runs` is absent: it names background processes the engineering
+ * workbench runs, not the detached host, and a provider genuinely differs there.
+ */
+export declare const HOST_BACKED_CAPABILITIES: {
+    readonly 'coordination.messages': "coordination";
+    readonly 'coordination.claims': "coordination";
+    readonly 'coordination.query': "coordination";
+};
+export interface HostCapabilityBacking {
+    /** True when a coordination service is mounted on this host. */
+    coordination: boolean;
+}
+/**
+ * Lowers any host-backed capability the host cannot support.
+ *
+ * Returns the SAME matrix object when nothing changed, so a caller can tell a
+ * downgrade happened without comparing every entry — and so registering an
+ * honest provider costs nothing.
+ */
+export declare function withHostBackedCapabilities(matrix: AgentCapabilityMatrix, backing: HostCapabilityBacking): AgentCapabilityMatrix;
+//# sourceMappingURL=hostBackedCapabilities.d.ts.map

package/dist/hostBackedCapabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostBackedCapabilities.d.ts","sourceRoot":"","sources":["../src/hostBackedCapabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EACV,qBAAqB,EAEtB,MAAM,sCAAsC,CAAA;AAE7C;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;;CAI+B,CAAA;AAEpE,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,YAAY,EAAE,OAAO,CAAA;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,qBAAqB,EAC7B,OAAO,EAAE,qBAAqB,GAC7B,qBAAqB,CAsBvB"}

package/dist/hostBackedCapabilities.js

@@ -0,0 +1,66 @@
+/**
+ * A provider may not advertise a capability the HOST does not have — §7.1.
+ *
+ * Most entries in `AGENT_HARNESS_CAPABILITIES` are facts about a provider: this
+ * agent can read files, that one streams. A few are not. Coordination between
+ * runs is a property of the HOST — whether a `CoordinationService` is mounted —
+ * and no provider can make it true by declaring it.
+ *
+ * 🔴 Today no adapter declares them, so nothing is currently wrong. This exists
+ * for the commit that changes that. When coordination tools land, someone will
+ * flip these to `available` in an adapter matrix, and the host they run on may
+ * still have no coordination service. The surface would then offer a claim map
+ * for a host that cannot answer, which is precisely the capability-honesty
+ * failure the matrix was introduced to prevent.
+ *
+ * ## Downgrade, not refuse
+ *
+ * A provider that over-claims is still useful for everything else it does, so
+ * refusing to register it would trade a small dishonesty for a total loss of the
+ * lane. The claim is lowered to `unsupported` with a reason naming the host as
+ * the source — `source: 'host'` is the honest attribution, because the provider
+ * did not decide this and a reader chasing the reason should look at the host.
+ */
+/**
+ * Capabilities whose truth is owned by the host, not the provider.
+ *
+ * Deliberately narrow. A capability belongs here only when NO provider
+ * implementation could make it true on a host that lacks the backing — which is
+ * why `background-runs` is absent: it names background processes the engineering
+ * workbench runs, not the detached host, and a provider genuinely differs there.
+ */
+export const HOST_BACKED_CAPABILITIES = {
+    'coordination.messages': 'coordination',
+    'coordination.claims': 'coordination',
+    'coordination.query': 'coordination',
+};
+/**
+ * Lowers any host-backed capability the host cannot support.
+ *
+ * Returns the SAME matrix object when nothing changed, so a caller can tell a
+ * downgrade happened without comparing every entry — and so registering an
+ * honest provider costs nothing.
+ */
+export function withHostBackedCapabilities(matrix, backing) {
+    let changed = false;
+    const next = { ...matrix };
+    for (const [capability, backedBy] of Object.entries(HOST_BACKED_CAPABILITIES)) {
+        const declared = matrix[capability];
+        // Only a POSITIVE claim is a lie worth correcting. `degraded`, `blocked` and
+        // `unsupported` already tell a surface not to rely on it.
+        if (!declared || declared.status !== 'available')
+            continue;
+        if (backing[backedBy])
+            continue;
+        changed = true;
+        next[capability] = {
+            status: 'unsupported',
+            // The HOST decided this, not the provider. A reader chasing the reason
+            // must be sent to the right place.
+            source: 'host',
+            reason: `This host has no ${backedBy} service mounted, so ${capability} cannot work here.`,
+        };
+    }
+    return changed ? next : matrix;
+}
+//# sourceMappingURL=hostBackedCapabilities.js.map

package/dist/hostBackedCapabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostBackedCapabilities.js","sourceRoot":"","sources":["../src/hostBackedCapabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAOH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,uBAAuB,EAAE,cAAc;IACvC,qBAAqB,EAAE,cAAc;IACrC,oBAAoB,EAAE,cAAc;CAC8B,CAAA;AAOpE;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CACxC,MAA6B,EAC7B,OAA8B;IAE9B,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,MAAM,IAAI,GAA0B,EAAE,GAAG,MAAM,EAAE,CAAA;IAEjD,KAAK,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,wBAAwB,CAAC,EAAE,CAAC;QAC9E,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAoC,CAAC,CAAA;QAC7D,6EAA6E;QAC7E,0DAA0D;QAC1D,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,WAAW;YAAE,SAAQ;QAC1D,IAAI,OAAO,CAAC,QAAuC,CAAC;YAAE,SAAQ;QAE9D,OAAO,GAAG,IAAI,CAAA;QACd,IAAI,CAAC,UAAoC,CAAC,GAAG;YAC3C,MAAM,EAAE,aAAa;YACrB,uEAAuE;YACvE,mCAAmC;YACnC,MAAM,EAAE,MAAM;YACd,MAAM,EAAE,oBAAoB,QAAQ,wBAAwB,UAAU,oBAAoB;SAC3F,CAAA;IACH,CAAC;IAED,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAA;AAChC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { type AgentCapabilityDescriptor, type AgentCapabilityMatrix, type AgentHarnessCapability, type AgentRuntimeProviderDescriptor, type AgentRuntimeSelection } from '@xenosystem/agent-interface-contract';
+export * from './runtimeProjection.js';
+export * from './fleetProjection.js';
+export * from './fleetBoardProjection.js';
+export * from './sessionBoardProjection.js';
+export * from './intakeClaim.js';
+export * from './intakeBoardProjection.js';
+export * from './workspaceKnowledge.js';
+export * from './knowledgeBoardProjection.js';
+export * from './hostBackedCapabilities.js';
+export * from './sessionMode.js';
+export * from './writeLease.js';
+export * from './landingOverlap.js';
+export * from './landingQueue.js';
+export * from './reviewProjection.js';
+export * from './combinationVerification.js';
+export * from './capabilityTier.js';
+export * from './runDiff.js';
+export * from './context/agentAttachedContextPrompt.js';
+export * from './context/agentModelContext.js';
+export * from './markdown/markdownWindowsPaths.js';
+export * from './runtime/agentReasoningEffort.js';
+export * from './runtime/agentRuntimeProvider.js';
+export * from './runtime/agentRuntimeProviderTypes.js';
+export * from './runtime/conversationRuntime.js';
+export * from './runtime/legacyAgentRuntimeEvents.js';
+export * from './workspace/workspaceSelectionContinuation.js';
+export declare const DEVELOPMENT_REQUIRED_CAPABILITIES: readonly ["development.execution", "turn.streaming", "tools.file.read", "tools.file.write", "tools.terminal"];
+export declare function createCapabilityMatrix(overrides?: AgentCapabilityMatrix, fallback?: AgentCapabilityDescriptor): Record<AgentHarnessCapability, AgentCapabilityDescriptor>;
+export declare function capabilityStatus(matrix: AgentCapabilityMatrix, capability: AgentHarnessCapability): AgentCapabilityDescriptor;
+export declare function isCapabilityUsable(descriptor: AgentCapabilityDescriptor): boolean;
+export declare function isDevelopmentProviderReady(provider: AgentRuntimeProviderDescriptor): boolean;
+export declare function missingDevelopmentCapabilities(provider: AgentRuntimeProviderDescriptor): AgentHarnessCapability[];
+export declare function selectAvailableProviders(providers: readonly AgentRuntimeProviderDescriptor[], includeUnavailable?: boolean): AgentRuntimeProviderDescriptor[];
+export declare function cloneProvider(provider: AgentRuntimeProviderDescriptor): AgentRuntimeProviderDescriptor;
+export type AgentRuntimeSelectionFailureCode = 'provider_not_found' | 'provider_unavailable' | 'model_not_found' | 'model_unavailable' | 'model_required' | 'reasoning_option_not_found';
+export type AgentRuntimeSelectionResult = {
+    ok: true;
+    selection: Readonly<AgentRuntimeSelection>;
+} | {
+    ok: false;
+    code: AgentRuntimeSelectionFailureCode;
+    safeReason: string;
+};
+export interface ResolveAgentRuntimeSelectionInput {
+    providerId: string;
+    modelId?: string;
+    reasoningOptionId?: string;
+}
+export declare function resolveAgentRuntimeSelection(providers: readonly AgentRuntimeProviderDescriptor[], input: ResolveAgentRuntimeSelectionInput): AgentRuntimeSelectionResult;
+export * from './capabilityRouting.js';
+export * from './fanOutPlanner.js';
+export * from './agentDiscovery.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,8BAA8B,EACnC,KAAK,qBAAqB,EAC3B,MAAM,sCAAsC,CAAA;AAE7C,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,2BAA2B,CAAA;AACzC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,kBAAkB,CAAA;AAChC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,qBAAqB,CAAA;AACnC,cAAc,cAAc,CAAA;AAC5B,cAAc,yCAAyC,CAAA;AACvD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,oCAAoC,CAAA;AAClD,cAAc,mCAAmC,CAAA;AACjD,cAAc,mCAAmC,CAAA;AACjD,cAAc,wCAAwC,CAAA;AACtD,cAAc,kCAAkC,CAAA;AAChD,cAAc,uCAAuC,CAAA;AACrD,cAAc,+CAA+C,CAAA;AAE7D,eAAO,MAAM,iCAAiC,+GAMQ,CAAA;AAEtD,wBAAgB,sBAAsB,CACpC,SAAS,GAAE,qBAA0B,EACrC,QAAQ,GAAE,yBAAyE,GAClF,MAAM,CAAC,sBAAsB,EAAE,yBAAyB,CAAC,CAM3D;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,qBAAqB,EAC7B,UAAU,EAAE,sBAAsB,GACjC,yBAAyB,CAE3B;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,yBAAyB,GAAG,OAAO,CAEjF;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,8BAA8B,GAAG,OAAO,CAK5F;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,8BAA8B,GACvC,sBAAsB,EAAE,CAI1B;AAED,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,SAAS,8BAA8B,EAAE,EACpD,kBAAkB,UAAQ,GACzB,8BAA8B,EAAE,CAKlC;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,8BAA8B,GAAG,8BAA8B,CAatG;AAED,MAAM,MAAM,gCAAgC,GACxC,oBAAoB,GACpB,sBAAsB,GACtB,iBAAiB,GACjB,mBAAmB,GACnB,gBAAgB,GAChB,4BAA4B,CAAA;AAEhC,MAAM,MAAM,2BAA2B,GACnC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,QAAQ,CAAC,qBAAqB,CAAC,CAAA;CAAE,GACxD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,gCAAgC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E,MAAM,WAAW,iCAAiC;IAChD,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,SAAS,8BAA8B,EAAE,EACpD,KAAK,EAAE,iCAAiC,GACvC,2BAA2B,CAyD7B;AAKD,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA"}

package/dist/index.js

@@ -0,0 +1,134 @@
+import { AGENT_HARNESS_CAPABILITIES, } from '@xenosystem/agent-interface-contract';
+export * from './runtimeProjection.js';
+export * from './fleetProjection.js';
+export * from './fleetBoardProjection.js';
+export * from './sessionBoardProjection.js';
+export * from './intakeClaim.js';
+export * from './intakeBoardProjection.js';
+export * from './workspaceKnowledge.js';
+export * from './knowledgeBoardProjection.js';
+export * from './hostBackedCapabilities.js';
+export * from './sessionMode.js';
+export * from './writeLease.js';
+export * from './landingOverlap.js';
+export * from './landingQueue.js';
+export * from './reviewProjection.js';
+export * from './combinationVerification.js';
+export * from './capabilityTier.js';
+export * from './runDiff.js';
+export * from './context/agentAttachedContextPrompt.js';
+export * from './context/agentModelContext.js';
+export * from './markdown/markdownWindowsPaths.js';
+export * from './runtime/agentReasoningEffort.js';
+export * from './runtime/agentRuntimeProvider.js';
+export * from './runtime/agentRuntimeProviderTypes.js';
+export * from './runtime/conversationRuntime.js';
+export * from './runtime/legacyAgentRuntimeEvents.js';
+export * from './workspace/workspaceSelectionContinuation.js';
+export const DEVELOPMENT_REQUIRED_CAPABILITIES = [
+    'development.execution',
+    'turn.streaming',
+    'tools.file.read',
+    'tools.file.write',
+    'tools.terminal',
+];
+export function createCapabilityMatrix(overrides = {}, fallback = { status: 'unsupported', source: 'provider' }) {
+    const entries = AGENT_HARNESS_CAPABILITIES.map((capability) => [
+        capability,
+        overrides[capability] ?? fallback,
+    ]);
+    return Object.fromEntries(entries);
+}
+export function capabilityStatus(matrix, capability) {
+    return matrix[capability] ?? { status: 'unsupported', source: 'provider' };
+}
+export function isCapabilityUsable(descriptor) {
+    return descriptor.status === 'available' || descriptor.status === 'degraded';
+}
+export function isDevelopmentProviderReady(provider) {
+    if (provider.availability !== 'available' && provider.availability !== 'degraded')
+        return false;
+    return DEVELOPMENT_REQUIRED_CAPABILITIES.every((capability) => (isCapabilityUsable(capabilityStatus(provider.capabilities, capability))));
+}
+export function missingDevelopmentCapabilities(provider) {
+    return DEVELOPMENT_REQUIRED_CAPABILITIES.filter((capability) => (!isCapabilityUsable(capabilityStatus(provider.capabilities, capability))));
+}
+export function selectAvailableProviders(providers, includeUnavailable = false) {
+    return providers
+        .filter((provider) => includeUnavailable || provider.availability !== 'unavailable')
+        .map(cloneProvider)
+        .sort((a, b) => a.displayName.localeCompare(b.displayName) || a.id.localeCompare(b.id));
+}
+export function cloneProvider(provider) {
+    return {
+        ...provider,
+        capabilities: Object.fromEntries(Object.entries(provider.capabilities).map(([key, value]) => [key, value ? { ...value } : value])),
+        models: provider.models.map((model) => ({
+            ...model,
+            ...(model.reasoningOptions
+                ? { reasoningOptions: model.reasoningOptions.map((option) => ({ ...option })) }
+                : {}),
+        })),
+    };
+}
+export function resolveAgentRuntimeSelection(providers, input) {
+    const provider = providers.find((candidate) => candidate.id === input.providerId);
+    if (!provider) {
+        return { ok: false, code: 'provider_not_found', safeReason: 'The selected runtime provider is no longer in the catalog.' };
+    }
+    if (provider.availability !== 'available' && provider.availability !== 'degraded') {
+        return {
+            ok: false,
+            code: 'provider_unavailable',
+            safeReason: provider.safeUnavailableReason || 'The selected runtime provider is unavailable.',
+        };
+    }
+    const requestedModelId = input.modelId || provider.defaultModelId;
+    const fallbackModel = provider.models.find((model) => model.isDefault && isModelUsable(model))
+        || provider.models.find(isModelUsable);
+    const model = requestedModelId
+        ? provider.models.find((candidate) => candidate.id === requestedModelId)
+        : fallbackModel;
+    if (requestedModelId && !model) {
+        return { ok: false, code: 'model_not_found', safeReason: 'The selected model is no longer advertised by this provider.' };
+    }
+    if (model && !isModelUsable(model)) {
+        return {
+            ok: false,
+            code: 'model_unavailable',
+            safeReason: model.safeUnavailableReason || 'The selected model is unavailable.',
+        };
+    }
+    if (!model && provider.allowsProviderDefaultModel !== true) {
+        return { ok: false, code: 'model_required', safeReason: 'This provider requires an available model selection.' };
+    }
+    const reasoningOptionId = input.reasoningOptionId
+        || model?.reasoningOptions?.find((option) => option.isDefault)?.id;
+    const reasoningOption = reasoningOptionId
+        ? model?.reasoningOptions?.find((option) => option.id === reasoningOptionId)
+        : undefined;
+    if (reasoningOptionId && !reasoningOption) {
+        return {
+            ok: false,
+            code: 'reasoning_option_not_found',
+            safeReason: 'The selected reasoning option is not advertised by this model.',
+        };
+    }
+    return {
+        ok: true,
+        selection: Object.freeze({
+            providerId: provider.id,
+            catalogRevision: provider.catalogRevision,
+            ...(model ? { modelId: model.id } : {}),
+            ...(reasoningOptionId ? { reasoningOptionId } : {}),
+            ...(model ? { runtimeModelId: reasoningOption?.runtimeModelId || model.id } : {}),
+        }),
+    };
+}
+function isModelUsable(model) {
+    return model.availability === 'available' || model.availability === 'degraded';
+}
+export * from './capabilityRouting.js';
+export * from './fanOutPlanner.js';
+export * from './agentDiscovery.js';
+//# sourceMappingURL=index.js.map