@hraness/sys1 0.17.0

package/dist/packs/core/pack.yaml

@@ -0,0 +1,50 @@
+version: 1
+pack: core
+revision: "2026.09.1"
+description: Experimental advisory checks for two narrow JavaScript and TypeScript changes.
+rules:
+  - id: core-new-empty-catch
+    applies:
+      paths: ["**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}"]
+      languages: [javascript, typescript]
+    ensure: >-
+      The change does not introduce a new empty JavaScript or TypeScript catch
+      block. A violation requires a complete catch body visible after the
+      change, with no executable statement, that was either newly added or
+      emptied by removing its last executable statement. Comments, whitespace,
+      and empty semicolon statements do not count as executable statements.
+      An unchanged or moved empty catch, removal of a catch, an incomplete
+      catch body, a Promise.catch callback, or catch text inside a string is
+      outside this rule. Any executable statement, including return, makes
+      the catch nonempty. Judge only the shown before and after code.
+    breaks: >-
+      The shown change adds a complete empty catch block or removes every
+      executable statement from a retained complete catch block, leaving
+      only whitespace, comments, or empty semicolon statements.
+    severity: P2
+    tiers: { medium: 0.8, high: 0.85 }
+    source: { kind: builtin }
+  - id: core-removed-test-assertions
+    applies:
+      paths: ["**/*.{test,spec}.{js,jsx,mjs,cjs,ts,tsx,mts,cts}", "**/{test,tests,__tests__}/**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}"]
+      languages: [javascript, typescript]
+    ensure: >-
+      The change does not remove the last visible behavioral assertion from
+      a retained JavaScript or TypeScript test callback. A violation requires
+      the complete test callback to be visible before and after, a removed
+      executable expect matcher, assert check, or explicit throw-on-failure
+      check, and no such check remaining or replacing it after. Assertion
+      count hints such as expect.assertions or expect.hasAssertions, logging,
+      comments, and mock setup are not behavioral assertions. A removed
+      whole test, an incomplete callback, a retained or replacement assertion,
+      and assertion text in a string are outside this rule. If a new or changed
+      helper call could contain a replacement check that is not shown, the
+      evidence is insufficient: do not report a violation. Do not infer tests
+      or helpers outside the shown code.
+    breaks: >-
+      A complete retained test callback had an executable behavioral assertion
+      before, loses its last such check in this diff, and contains no behavioral
+      check or possible replacement assertion helper call afterward.
+    severity: P2
+    tiers: { medium: 0.7, high: 0.85 }
+    source: { kind: builtin }

package/dist/profile.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { type SystemOneRequest } from "./protocol.ts";
+declare const profileDefinitionSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    revision: z.ZodString;
+    model: z.ZodString;
+    questions: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"noul">;
+        instructions: z.ZodOptional<z.ZodType<import("./protocol.ts").EntryType, unknown, z.core.$ZodTypeInternals<import("./protocol.ts").EntryType, unknown>>>;
+        criteria: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            true: z.ZodOptional<z.ZodType<import("./protocol.ts").EntryType, unknown, z.core.$ZodTypeInternals<import("./protocol.ts").EntryType, unknown>>>;
+            false: z.ZodOptional<z.ZodType<import("./protocol.ts").EntryType, unknown, z.core.$ZodTypeInternals<import("./protocol.ts").EntryType, unknown>>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"choice">;
+        instructions: z.ZodOptional<z.ZodType<import("./protocol.ts").EntryType, unknown, z.core.$ZodTypeInternals<import("./protocol.ts").EntryType, unknown>>>;
+        criteria: z.ZodRecord<z.ZodString, z.ZodType<import("./protocol.ts").EntryType, unknown, z.core.$ZodTypeInternals<import("./protocol.ts").EntryType, unknown>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"score">;
+        instructions: z.ZodOptional<z.ZodType<import("./protocol.ts").EntryType, unknown, z.core.$ZodTypeInternals<import("./protocol.ts").EntryType, unknown>>>;
+        criteria: z.ZodArray<z.ZodType<import("./protocol.ts").EntryType, unknown, z.core.$ZodTypeInternals<import("./protocol.ts").EntryType, unknown>>>;
+    }, z.core.$strict>], "type">>;
+}, z.core.$strict>;
+export type ProfileDefinition = z.infer<typeof profileDefinitionSchema>;
+export type ReadonlyJsonValue = string | number | boolean | null | readonly ReadonlyJsonValue[] | {
+    readonly [key: string]: ReadonlyJsonValue;
+};
+export type ReadonlyEntryType = string | null | readonly ReadonlyJsonValue[] | {
+    readonly [key: string]: ReadonlyJsonValue;
+};
+export type ReadonlyProfileQuestion = {
+    readonly type: "noul";
+    readonly instructions?: ReadonlyEntryType | undefined;
+    readonly criteria?: {
+        readonly true?: ReadonlyEntryType | undefined;
+        readonly false?: ReadonlyEntryType | undefined;
+    } | null | undefined;
+} | {
+    readonly type: "choice";
+    readonly instructions?: ReadonlyEntryType | undefined;
+    readonly criteria: {
+        readonly [key: string]: ReadonlyEntryType;
+    };
+} | {
+    readonly type: "score";
+    readonly instructions?: ReadonlyEntryType | undefined;
+    readonly criteria: readonly ReadonlyEntryType[];
+};
+export interface ReadonlyProfileDefinition {
+    readonly version: 1;
+    readonly id: string;
+    readonly revision: string;
+    readonly model: string;
+    readonly questions: {
+        readonly [key: string]: ReadonlyProfileQuestion;
+    };
+}
+export interface DecisionProfile {
+    /** Frozen local identity and decision recipe. Never sent on the wire. */
+    readonly definition: ReadonlyProfileDefinition;
+    /** Compose a fresh ordinary request; no interpolation, overrides, or I/O. */
+    request(state: unknown): SystemOneRequest;
+}
+export type ProfileErrorCode = "invalid_profile" | "invalid_request";
+/** Contains no supplied identifiers, instructions, states, or validation details. */
+export declare class Sys1ProfileError extends Error {
+    readonly code: ProfileErrorCode;
+    constructor(code: ProfileErrorCode);
+}
+/**
+ * A named, revisioned decision recipe for a gateway or embedded router.
+ * The exact backend/model pin keeps the router from silently switching routes;
+ * operators remain responsible for verifying the model served at that endpoint.
+ */
+export declare function createProfile(input: unknown): DecisionProfile;
+export {};

package/dist/protocol.d.ts

@@ -0,0 +1,148 @@
+import { z } from "zod";
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type EntryType = string | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare const PROTOCOL_LIMITS: {
+    readonly maxBodyBytes: 1048576;
+    readonly maxStateBytes: 262144;
+    readonly maxQuestions: 64;
+    readonly maxQuestionNameChars: 128;
+    readonly maxInstructionsChars: 4096;
+    readonly maxCriterionChars: 1024;
+    readonly maxOptionChars: 256;
+    readonly maxChoiceOptions: 255;
+    readonly minScoreLevels: 2;
+    readonly maxScoreLevels: 10;
+    readonly maxModelChars: 128;
+};
+export declare const entrySchema: z.ZodType<EntryType>;
+export declare const noulQuestionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"noul">;
+    instructions: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    criteria: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        true: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+        false: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const choiceQuestionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"choice">;
+    instructions: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    criteria: z.ZodRecord<z.ZodString, z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+}, z.core.$strip>;
+export declare const scoreQuestionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"score">;
+    instructions: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    criteria: z.ZodArray<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+}, z.core.$strip>;
+export declare const questionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"noul">;
+    instructions: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    criteria: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        true: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+        false: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"choice">;
+    instructions: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    criteria: z.ZodRecord<z.ZodString, z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"score">;
+    instructions: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    criteria: z.ZodArray<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+}, z.core.$strip>], "type">;
+export declare const systemOneRequestSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    state: z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>;
+    questions: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"noul">;
+        instructions: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+        criteria: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            true: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+            false: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"choice">;
+        instructions: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+        criteria: z.ZodRecord<z.ZodString, z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"score">;
+        instructions: z.ZodOptional<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+        criteria: z.ZodArray<z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+export type NoulQuestion = z.infer<typeof noulQuestionSchema>;
+export type ChoiceQuestion = z.infer<typeof choiceQuestionSchema>;
+export type ScoreQuestion = z.infer<typeof scoreQuestionSchema>;
+export type Question = z.infer<typeof questionSchema>;
+export type SystemOneRequest = z.infer<typeof systemOneRequestSchema>;
+export declare const noulAnswerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"noul">;
+    noul: z.ZodNumber;
+}, z.core.$strip>;
+export declare const choiceAnswerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"choice">;
+    choice: z.ZodString;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    confidence: z.ZodNumber;
+}, z.core.$strip>;
+export declare const scoreAnswerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"score">;
+    score: z.ZodNumber;
+    legend: z.ZodRecord<z.ZodString, z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    confidence: z.ZodNumber;
+}, z.core.$strip>;
+export declare const answerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"noul">;
+    noul: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"choice">;
+    choice: z.ZodString;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    confidence: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"score">;
+    score: z.ZodNumber;
+    legend: z.ZodRecord<z.ZodString, z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    confidence: z.ZodNumber;
+}, z.core.$strip>], "type">;
+export declare const systemOneResponseSchema: z.ZodObject<{
+    model: z.ZodString;
+    answers: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"noul">;
+        noul: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"choice">;
+        choice: z.ZodString;
+        probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        confidence: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"score">;
+        score: z.ZodNumber;
+        legend: z.ZodRecord<z.ZodString, z.ZodType<EntryType, unknown, z.core.$ZodTypeInternals<EntryType, unknown>>>;
+        probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        confidence: z.ZodNumber;
+    }, z.core.$strip>], "type">>;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type NoulAnswer = z.infer<typeof noulAnswerSchema>;
+export type ChoiceAnswer = z.infer<typeof choiceAnswerSchema>;
+export type ScoreAnswer = z.infer<typeof scoreAnswerSchema>;
+export type Answer = z.infer<typeof answerSchema>;
+export type SystemOneResponse = z.infer<typeof systemOneResponseSchema>;
+export interface GatewayError {
+    error: {
+        type: string;
+        message: string;
+        details?: JsonValue;
+    };
+}
+export declare function errorBody(type: string, message: string, details?: JsonValue): GatewayError;
+export declare function serializedBytes(value: JsonValue): number;

package/dist/qualification.d.ts

@@ -0,0 +1,22 @@
+import type { LocalBackendConfig } from "./config.ts";
+export type BackendQualificationStatus = "pass" | "warn" | "fail";
+export interface BackendQualificationCheck {
+    id: "models" | "limits" | "systemone";
+    status: BackendQualificationStatus;
+    summary: string;
+    detail?: string;
+}
+export interface BackendQualificationReport {
+    version: 1;
+    backend: string;
+    base_url: string;
+    model: string;
+    ok: boolean;
+    checks: BackendQualificationCheck[];
+}
+export interface BackendQualificationOptions {
+    probeTimeoutMs: number;
+    requestTimeoutMs: number;
+    fetchFn?: typeof fetch;
+}
+export declare function qualifyBackend(backend: LocalBackendConfig, options: BackendQualificationOptions): Promise<BackendQualificationReport>;

package/dist/response.d.ts

@@ -0,0 +1,10 @@
+import { type SystemOneRequest, type SystemOneResponse } from "./protocol.ts";
+/**
+ * Validate the wire shape and its relationship to the original questions.
+ * Three decimal places remain the default. A protocol adapter may explicitly
+ * select two decimal places for a backend that publishes that precision.
+ * Require a normalized distribution inside the half-unit rounding intervals,
+ * and a compatible expected score within its own half-unit interval.
+ * This is arithmetic consistency, not an assessment of calibration or accuracy.
+ */
+export declare function validateResponseForRequest(request: SystemOneRequest, value: unknown, roundingDecimals?: 2 | 3): SystemOneResponse;

package/dist/router.d.ts

@@ -0,0 +1,62 @@
+import type { RoutingPolicy } from "./config.ts";
+import type { SystemOneRequest } from "./protocol.ts";
+/** Local means builtin inference or a loopback URL; other URLs are hosted. */
+export type BackendKind = "hosted" | "local";
+/** Published per-backend request limits; absent fields mean unbounded. */
+export interface BackendCapabilities {
+    /** Largest criteria count a single choice/score question may carry. */
+    maxOptions?: number;
+    /** Largest question count a single request may carry. */
+    maxQuestions?: number;
+}
+export interface BackendCandidate {
+    /** Unique backend name. The built-in hosted Jev backend is "typesafe". */
+    name: string;
+    kind: BackendKind;
+    /** Whether the backend answered a bounded probe just now. */
+    available: boolean;
+    /** Model ids this backend reported or is configured to serve. */
+    models: string[];
+    /** Parameter count in billions; null when unknown (always null for hosted). */
+    size_b: number | null;
+    /** Operator-set cost ordering; lower is cheaper. */
+    cost_rank: number;
+    /**
+     * Explicit-only backends only serve requests that explicitly name them —
+     * they never receive unpinned policy-order fallback traffic.
+     */
+    explicitOnly?: boolean;
+    /** Probed or configured request limits. */
+    capabilities?: BackendCapabilities;
+}
+/** What one request demands of a backend, computed from its questions. */
+export interface RequestNeeds {
+    /** Largest criteria count across choice/score questions (noul counts 2). */
+    maxOptions: number;
+    /** Question count in the request. */
+    questions: number;
+}
+export declare function requestNeeds(request: SystemOneRequest): RequestNeeds;
+export type RouteChoice<T extends BackendCandidate = BackendCandidate> = {
+    ok: true;
+    backend: T;
+    reason: string;
+} | {
+    ok: false;
+    reason: "unknown_model" | "model_unavailable" | "request_unsupported" | "policy_restricted" | "no_backend_available";
+    detail: string;
+};
+/**
+ * Pick a backend for one System One request.
+ *
+ * A request naming `backend/model` pins an exact backend. A bare model name
+ * matches any backend listing it, in policy order. No model means policy
+ * order among automatic candidates: runtime configuration admits hosted Jev
+ * and the selected local model. `auto` prefers Jev; `prefer-local` reverses
+ * that order. Other installed models and HTTP backends need an explicit pin.
+ *
+ * `needs` makes selection capability-aware: a backend whose published limits
+ * the request exceeds is never chosen. Explicit-only candidates are skipped
+ * unless the request names their model or backend/model.
+ */
+export declare function chooseBackend<T extends BackendCandidate>(policy: RoutingPolicy, requestedModel: string | undefined, candidates: T[], needs?: RequestNeeds): RouteChoice<T>;

package/dist/runtime.d.ts

@@ -0,0 +1,22 @@
+import { type Sys1Client } from "./client.ts";
+import { type Sys1Config } from "./config.ts";
+import { LocalRunner } from "./local/runner.ts";
+export interface RouterOptions {
+    config: Sys1Config;
+    /** Explicit credential environment. Pass {} for credential-free routing. */
+    env: NodeJS.ProcessEnv;
+    /** Explicit model store. Omit to use only registered HTTP or hosted backends. */
+    home?: string;
+    /** Caller-owned runner: disposal remains the caller's responsibility. */
+    localRunner?: LocalRunner;
+    /** Optional transport used only for configured remote backends and probes. */
+    fetchFn?: typeof fetch;
+}
+export interface EmbeddedRouter extends Sys1Client {
+    /** In-process Fetch handler. Does not listen on any TCP port. */
+    fetch(request: Request): Promise<Response>;
+    /** Cancel this router's work and dispose its owned local runner. Idempotent. */
+    dispose(): Promise<void>;
+}
+/** Embedded Bun router with explicit configuration and no daemon lifecycle. */
+export declare function createRouter(options: RouterOptions): EmbeddedRouter;

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@hraness/sys1",
+  "version": "0.17.0",
+  "description": "Sys1 helps coding agents review changes against your repository's rules, with probability-scored answers from hosted Jev, a local model, or your own server.",
+  "type": "module",
+  "license": "MIT",
+  "packageManager": "bun@1.3.14",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hraness/sys1.git"
+  },
+  "homepage": "https://sys1.io",
+  "bugs": {
+    "url": "https://github.com/hraness/sys1/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "bun": ">=1.3.14"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js",
+      "default": "./dist/client.js"
+    }
+  },
+  "bin": {
+    "sys1": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build:dist": "bun scripts/build-dist.ts",
+    "check:package": "bun scripts/package-smoke.ts",
+    "check:native": "bun scripts/check-native.ts",
+    "test": "bun test ./src ./test",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "check": "bun run typecheck && bun run check:release-info && bun run brand:check && bun run test && bun run build:dist && bun run check:package",
+    "prepack": "bun run check",
+    "brand:generate": "bun scripts/generate-brand-icons.ts",
+    "brand:check": "bun scripts/generate-brand-icons.ts --check",
+    "release:sync": "bun scripts/sync-public-release.ts --write",
+    "check:release-info": "bun scripts/sync-public-release.ts --check"
+  },
+  "dependencies": {
+    "zod": "4.6.2"
+  },
+  "optionalDependencies": {
+    "node-llama-cpp": "3.20.0"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.14",
+    "@types/node": "26.2.0",
+    "playwright-core": "1.58.2",
+    "sharp": "0.35.3",
+    "typescript": "6.0.3"
+  },
+  "trustedDependencies": [
+    "node-llama-cpp"
+  ],
+  "keywords": [
+    "coding-agents",
+    "agent-skills",
+    "code-review",
+    "jev",
+    "system-one",
+    "typescript",
+    "codex",
+    "claude-code",
+    "devin"
+  ]
+}