dsh-plugin-freecodego

dsh-plugin-freecodego

FreeCodeGo for DeepSeek Harness — a Cordis bundle that adds the FreeCodeGo engine inventory, a managed free-model gateway, per-provider accounts, media generation, and the engineering (code-graph + memory) toolchain to DeepSeek Harness (dsh).

English | 中文

FreeCodeGo is not a DeepSeek product, and this is not an official DeepSeek distribution: it is a plugin that mounts into a Harness you install yourself. See TRADEMARK.md for the naming policy that applies to forks of this repository.

Screenshots

The five views below are the plugin as it looks mounted: the plugin market card shows the same set, and the first one is what that card previews.

Model picker — the managed catalog and the free providers it reads, grouped by provider, each row carrying its own free and latency label; the composer's engine selector sits beside it.

Accounts and providers — Settings → FreeCodeGo → Accounts & providers: each provider's key stays in the Harness host, and that provider's free-model roster is listed under it.

Engineering enhancement — the master switch and what sits behind it: engineering skills, project-long-term memory, the code graph, post-implementation verification, and multi-role review.

Plugin safety and updates — conflict protection at load time, the release update check, and the unified MCP / Skill capability layer.

Community picks — the DSH market ranking and the MCP.SO directory, installed into the local Harness with one click.

What it adds

• Managed model catalogs — one picker over the FreeCodeGo gateway and the free providers it manages (OpenCode, Logfare, SenseNova, NVIDIA, VyceAI, Kilo, Agnes, Cline, WorkBuddy International, Qoder, TRAE, AntSeed, Groq Whisper), each row carrying its own health, rate, and training-data label.
• Native engines — a session runs on DeepSeek, Codex, or Claude, each behind its own verified runtime, with this plugin's router as the only Harness AgentFactory.
• Advisor review loop — an independent, read-only reviewer that steers the active Agent with bounded findings.
• Code review — an OCR-style reviewer over the change itself (the workspace, a ref range from its merge base, or one commit), with four layer-resolved rule sets, per-file coverage accounting, three report formats, adversarial re-checking of high-severity findings, and an opt-in stop-time gate.
• Design pack (behind its own master switch, off) — composition-shaped frame and video design (17 Skills plus five read-only tools, rendering with a browser already on the machine), a searchable 34-table UI/UX catalogue, eleven vendored craft rulebooks, deterministic design detection, React Bits components fetched on demand, and upstream's design-direction Skills.
• Engineering enhancement (behind one master switch) — multi-engine engineering review, a multi-member team, CodeGraph / Graphify code graphs, durable per-project engineering memory, checkpoints and a hunk journal, a repository map, and deterministic scan inspection.
• Context and cost discipline — Headroom output compression (including code skeletonization), deferred tool schemas with tool_search, cache-cold clearing with spill recall, a model-visible context budget, and cache-miss attribution.
• Guardrails — a declarative command policy, Plan Mode, folder trust, a credential-path shield that also covers native engines, and credential screening on memory writes.
• Companion character — the small figure beside the composer and on the sidebar rail: a pose derived from the session (never declared by it), two pools that rotate what is drawn on the shared clock without moving the state, a freecodego_companion_face request the model may make, and a short sad face when a tool call comes back a failure. One character in two seats, and the two always agree.
• Model menu control — the provider and model rows the chat picker shows, non-interactive price/health labels on the stock menu, a picker label that echoes the durable selection, and a reconnect retry that does not empty an open menu.
• Capabilities — MCP servers, Skill roots (including skills.sh installs), LSP auto-mount, calendar scheduling rules, declarative hook chains, media generation and audio transcription, voice input, agent presets, and personas.
• Release updates — the plugin reads this repository's releases and installs the bundle built for the Harness you are running.

Every feature below states the setting that gates it, and where something is off by default it says so. The decision behind each one is written up in plugin/packages/freecodego/harness-plugin/README.md, the top-level feature document.

Free models

Every free row below comes from the provider's own directory, read when you open the picker, so this is what those directories returned on 2026-10-19 (sorted, where the picker keeps directory order) — and the picker is the count that is true when you look.

These lists follow their directories: a route upstream retires leaves the table on the next read, which is why it is generated by scripts/generate-free-model-tables.ts rather than remembered.

TRAE, Cline, WorkBuddy International, Agnes publish no stable roster, so their rows are counted when they arrive rather than listed here.

14 Logfare rows sit behind a training-data opt-in, which the picker labels rather than hides.

deepseek-v4.1-flash is also free here through two of the account pools above: Cline keeps it in its free half, and WorkBuddy International covers it for as long as its promotion runs.

Feature tour

Engines and routing

• Three engines, one router. DeepSeek executes in the official AgentLoop; Codex and Claude run behind a managed native runtime (a child-process host plus the Host-in-process Claude Agent SDK runtime) and stream back through the Host bridge. The router is the only Harness AgentFactory, so a session asked for a native engine never silently falls back to DeepSeek.
• Admission, not assumption. A native engine is admitted only when its verified manifest, digest, protocol ABI, worker path, and state directory arrive together. Runtimes are downloaded through one shared path that hashes while it streams, retries a transient transfer once, and treats a digest mismatch as final.
• Defaults. setDefaultEngine and setDefaultModel set what new sessions start on and persist in the settings document of this plugin's own composition entry (freecodego-harness-plugin); existing sessions keep their durable plan.
• Subagent routing (autoSubagentModelSelection, on). Every live text-model route is synchronized into Harness's subagent-model-selection, so new top-level sessions receive provider / model / reasoning_effort plus an on-demand list_subagent_models discovery tool. Children inherit the parent's execution engine and may override the exact LLM route per delegation; a temporarily failing provider keeps its last authorized routes.
• Third-party plugin tools in native sessions. Codex and Claude project the same Agent-scoped tool schemas DeepSeek sees — including tools registered by later plugins — with no name allowlist, and calls return through the Host ToolRuntime so the owning plugin keeps validation, permissions, audit, and cancellation. Codex refreshes the inventory before every prompt; Claude rebuilds its in-process MCP server for every query.
• Local routes. OpenAI-compatible and Anthropic-compatible providers use the existing dsh-llm-pi-ai plugin and the shared Models settings editor; API keys are stored through the Harness credential service and never reach the browser.
• Zcode GLM-5.3 Flash promotion. The Zcode directory annotates glm-5.3-flash only when the active Z.AI account holds a Coding Plan credential, and the limited-free window (Asia/Shanghai, 23:00–09:00, before the 20th of each month) is computed Host-side — no client clock or account claim can grant the entitlement.

Model catalogs, providers, and accounts

• One catalog, many upstreams. The picker lists the FreeCodeGo gateway together with the free providers the plugin manages: OpenCode, Logfare, SenseNova, NVIDIA, VyceAI, Kilo, Agnes, Cline, WorkBuddy International, Qoder, TRAE, and the private-key gateway, with Groq Whisper for audio transcription. Rows carry health, rate, and training-data labels, refreshed through bounded cache TTLs, and a provider that temporarily fails keeps its last authorized routes rather than emptying the picker.
• Free models through the private-key gateway, with one click. The Accounts-and-providers page carries one card for it: a download button fetches the pinned runtime into the Harness home, the Host generates and vaults a secp256k1 identity for it — nothing is written to ~/.antseed, and the key is handed to the browser only on an explicit export click — and a session-scoped gateway switch starts the runtime and publishes its catalog at http://127.0.0.1:8390/v1. While the gateway is open, its free text models join the picker under antseed, and its free image models become selectable as the image model under Overview, generated through the runtime's own image endpoint on the same loopback address. Only free routes are wired up: no deposit, no payment channel. The switch is never persisted, so a restart asks again, and the per-provider model-list controls cover it like any other provider.
• Provider-specific adapters over shared account pools. Each free provider has its own upstream contract (there is a measured reason not to reuse one generic OpenAI-compatible adapter), and the four pooled families — Cline, WorkBuddy International, Qoder, and TRAE — rotate through accounts: quota is issued per model or per account, requests rotate, and an HTTP 401 reauthentication failure or a 402/429 quota response cools the affected account before the next one is tried.
• Sign-in flows. WorkBuddy International uses the device authorization flow (a browser URL the user confirms, then polling) and stores access/refresh tokens through the Host credential service under WORKBUDDY_AUTH; multiple accounts can be added and removed independently. Agnes registers or logs in through its control-plane endpoints and creates a default API key, stored under AGNES_AUTH / AGNES_API_KEY. Cline and Logfare credentials likewise live as credential references.
• Browser-mediated OAuth sign-in. A Harness plugin has no window to receive a browser fragment and no freecodego:// handler, so sign-in drives the backend's own /auth/oauth/{provider}/start with redirect=/oauth/desktop?state=<ours>&plugin=1, polls GET /auth/oauth/desktop/poll until the issued pair arrives, and adopts that pair into the Host credential vault — the backend stores it under the state it was handed and shows a plain confirmation page instead of a deep link. The same card completes MFA, binds or creates the account, and sends the verification code, all through Host Remotes.
• What the model picker shows is the user's decision. The chat model list is the stock Harness menu and the Host registers every adapter it can serve, so the Accounts-and-providers page is where a provider or a single model is switched out of it. Storage is negative — visible unless recorded hidden — with two declared exceptions: a metered provider's priced rows default to hidden and a curated provider's unnamed rows default to hidden, so nothing changes for a user who never opens the controls while a newly added, priced model does not switch itself on. The control reaches a menu that is already open beside it, because the decision belongs to the provider rather than to whichever page rendered it.
• The stock menu is labelled, not replaced. The official selector keeps ownership of selection, focus, scrolling, and reasoning effort; this plugin only appends non-interactive labels — source, price class, provider health — to rows that expose the stable ARIA menu contract, so the menu teaches which rows are free, metered, or degraded without a second picker to keep in sync.
• A refusal never reads as an applied selection. The picker's own label is kept in sync with the Session's durable selection, and a refused selectModel resolves with the Remote failure rather than throwing, so the echo checks the result instead of only watching for a throw — otherwise a refusal would clear the reason it had just written. A separate retry layer absorbs a short-lived Host reconnect (1m, 10m, 30m backoff) without clearing the last directory, so a menu that was open when the carrier dropped recovers instead of going empty.
• A cold catalog in milliseconds, not seconds. The Host builds its model catalog by asking every registered route for its model list at once and waiting for the slowest answer; twelve of this deployment's thirteen routes belong to this plugin and are the only ones that must read a network directory. Measured against a restarted Host, the first catalog took 5,528 ms and the warm one 12 ms — 5.5 seconds in which the menu had no provider group to draw, which is exactly what makes an opening picker look like it never opened. The FreeCodeGo half is therefore answered from the directory this deployment already knows, not from a fresh round of provider reads.
• One failure table, three decisions. The same failure arrives in a different shape from every route — a fetch rejection, a status code on a custom error, a DOMException from an abort signal, an adapter's machine code, a provider's own wording — and reacting to the message at each call site is how a rate limit gets retried forever while a context overflow is retried until the budget is gone. Every failure is classified once, and each kind maps to one decision: retry, cool the account down, or fail the turn.
• Redaction is the rule. The browser receives only redacted state: no provider credential, session token, or API key is ever sent to the UI, and no parallel credential protocol is added beside the Harness one.
• Gateway account, billing, and plans. With gateway.baseUrl configured (default https://freecodego.com, HTTPS required) the settings surface shows account, quota, and usage details, selects payment methods and plans, opens checkout links, polls orders, and renders the live model pricing table, reusing the FreeCodeGo v1 routes for mobile authentication, bootstrap/model state, quota, runtime health, pricing, plans, checkout, and order polling. Payment verification/cancellation and receipt-email delivery are wired; provider-specific payment confirmation, binary receipt download, complete runtime artifact coverage, clean-profile installation, and assembled Web E2E remain release gates.
• Media defaults (this entry's mediaDefaults). freecodego_generate_image, freecodego_generate_video, freecodego_generate_audio, and freecodego_transcribe_audio read the live default at execution time; the model-facing schema deliberately has no model override. Gateway media requests reuse the Host-vault account token, base64 images are admitted to Harness attachment storage and returned as image content blocks, and generated audio is saved under the workspace's .freecodego/generated-media.
• Image and video generation is one switch away from gone (mediaGenerationEnabled, on by default). It governs freecodego_generate_image, freecodego_generate_video, and the legacy agnes_generate_image / agnes_generate_video names, and switching it off unregisters them so they leave the model's tool list instead of failing at call time. freecodego_generate_audio and freecodego_transcribe_audio are outside it: one writes into the active workspace and the other reads out of it.
• Image and video routes follow the provider, not the model name. Image generation speaks the OpenAI Images contract (/images/generations, /images/edits when sources are attached), Seedream's image: [...] fusion body, Gemini's :generateContent, Imagen's :predict, and DashScope's multimodal-generation. Video generation speaks nine: Kling (text2video / image2video / multi-image2video), Ark (/contents/generations/tasks), DashScope's async video-synthesis, MiniMax Hailuo, Vidu, Gemini's Veo :predictLongRunning, xAI's /videos/generations including edits and extensions, OpenAI's /videos, and the gateway's portable shape for everything unrecognized. The model roster is read live from the Harness model directory, the managed catalog, Logfare, and Agnes rather than pinned, and the package README carries the full table.

Advisor review loop

• An independent reviewer, enabled by default on the public freecodego/hy3 route, reads durable turn events with a separate model context and holds only bounded, read-only workspace tools (read, glob, grep). Credentials, hidden reasoning, and unrestricted primary-Agent tools are never copied into the review context.
• Every DeepSeek, Codex, and Claude Agent receives advisor_status, advisor_review, and advisor_notes, so the active Agent can inspect the reviewer, ask for a second opinion at a checkpoint, and consume prior findings without a separate UI action.
• A concrete concern or blocker steers the Agent; low-severity or cooldown findings are injected at the next safe step. Native Codex and Claude consume steering as a subsequent native turn and stage injections until the next user turn. Findings and token usage are appended to the Harness session; with Agent control off they stay record events only.
• Route and delivery settings apply live, and native sessions refresh their projected Harness tools before each turn.

Engineering enhancement

Engineering Enhancement sits behind one master switch (engineeringEnabled, on by default). It mounts audited bundled engineering Skills, static asset Doctor checks, bounded declared-script verification, and Host-owned tools shared by DeepSeek, Claude, and Codex. Switching it off stands the whole pack down. The settings page holds the master switch; the detailed controls live in the dynamic Engineering sidebar entry.

Multi-engine review and verification

• engineering_team_start keeps the current root Agent on its selected engine while starting isolated DeepSeek, Codex, and Claude child Agents for a bounded, read-only review of an objective and a draft plan, with an optional cross-examination round. Children cannot edit files, execute shell commands, create another team, or change permissions. Participants may be toggled independently, and the settings panel reports whether the Codex/Claude runtime is installed before allowing one to be enabled.
• Quorum is reached only when the configured minimum number of participants completes; missing runtimes and failed participants are reported independently. The team runs in the foreground or returns a council_* id for polling with engineering_team_status, engineering_team_cancel stops all children, and completed reports stay available through engineering_team_report after the parent session is restored. engineeringCouncilAutoRun (off) can run a review automatically after an approved plan, so users keep explicit control by default.
• Jobs expose an explicit lifecycle (queued, running, awaiting_approval, implementing, verifying, terminal states) persisted as session events, so an interrupted active job is restored as stale rather than silently lost. Approval records carry a plan digest, workspace fingerprint, policy digest, and expiry; a change to any of them fails closed and requires a fresh review.
• A completed report is evidence, not edit permission. The user must explicitly approve or reject it before implementation; only an approved report can run verification, and the primary Agent must call engineering_team_mark_implemented with a bounded summary before engineering_team_verify is accepted.
• Verification is computed, not inferred. Every stage result carries the command that ran and the exit status it returned, and a stage that could not run reports skipped, `unavailab