SYNAPTIC Expert

AI-assisted development for engineers who care about traceability. Decision Gates, project memory, audit trail — and your choice of provider.

Most AI coding tools answer your prompt and forget. SYNAPTIC Expert remembers what you've decided, validates how it responds, and leaves an audit trail you can defend later.

Built for three kinds of users:

Developers who want higher-quality output without manually re-prompting the model after every weak answer.
Technical teams that need to justify AI-assisted decisions to reviewers, auditors, or future selves — with traces that aren't just chat scrollback.
Tech leads and architects who care that the assistant stays consistent across days, weeks, and people working on the same project.

Three pillars

Trust

Every response is structurally validated before it reaches you. When the model proposes a real architectural choice, it surfaces it as an interactive Decision Gate — a card with concrete options, their trade-offs and risk profile, where you click your pick (or propose your own alternative), so the call is made by you, not assumed by the model. When the agent edits code, the extension type-checks (and lints) the touched files and feeds errors back so it self-corrects before the cycle ends — and newly-written code is grounded against a real language grammar to catch hallucinated imports before they land.

Memory

Your project's accumulated context — decisions taken, learnings captured, contradictions detected — travels with every cycle. The longer you work in a project, the more relevant the assistance gets, because it's grounded in your prior work and not a fresh chat each time. That memory isn't limited to what's recent, either: once history rolls into the project's long-term archive, asking about a decision from weeks ago retrieves the real record instead of losing it to scrollback.

Control

Bring your own API key. Pick from multiple providers, switching whenever you want. Your code goes directly to the LLM provider you selected — no proxy, no middleman. Project memory stays in your repo, in your control.

Multi-provider, your choice

Provider	Models supported
Anthropic	Claude Opus 4.x, Sonnet 4.x, Haiku
OpenAI	GPT-4.1, GPT-4o, o3, o4-mini
Google Gemini	2.5 Pro/Flash, 2.0 Flash
OpenRouter	80+ curated models via aggregator
xAI Grok	Grok 3, Grok 3 Mini, Grok 2
Qwen (Alibaba)	Qwen3-coder-next, Qwen 3.7 Max, Qwen3-coder Plus/Flash
DeepSeek	V4 Pro, V4 Flash
Kimi (Moonshot)	K2.7-code, K2.7-code-highspeed, K2.6
Claude Code	Local CLI integration
Codex CLI	Local OpenAI CLI integration
Gemini CLI	Local Google CLI integration

All requests route directly from your machine to the provider you chose. Pricing varies by model — see each provider's official pricing page for current rates.

How a typical cycle looks

You describe what you want. The assistant reviews your project's context, your recent decisions, and your prompt. From there, one of three things happens:

A focused clarification when intent is ambiguous.
An interactive Decision Gate when there's a real architectural choice to make — you click an option (or propose your own), the agent continues in the same cycle.
A structured response — validated before you see it. If tools are involved, you watch each step execute, the agent type-checks its own edits and self-corrects, and you can interrupt at any time.

Every cycle is recorded in the Audit tab, so you can come back later and see what changed, what was decided, why, and what the alternatives were.

Three modes

Architect Mode — Analysis only. Read-only by design — it only gets file-reading tools, so it physically cannot write even if the model tries. Useful for planning, code review, exploring trade-offs.
Plan Mode — Produces a structured plan document for your review (Goal, Scope, Files to modify, Steps, Risks, Rollback, Open questions) using read-only tools only. Click "Execute Plan" in chat to run it — if the workspace is a git repo, execution runs on an auto-created isolation branch so you review the diff before merging.
SYNAPTIC Mode — Full protocol with tool execution, interactive Decision Gates, and in-loop verification. Use this when you're ready to build.

You switch modes per cycle. Same conversation, different capability.

Project Rules — your conventions, auto-applied

Most AI tools forget your project preferences between conversations. SYNAPTIC lets you write them down once in a file the agent will read on every cycle.

A rule is plain Markdown with a short YAML frontmatter at the top:

---
name: typescript-strict
description: TS conventions for src/
whenFilesMatch: ["src/**/*.ts", "src/**/*.tsx"]
whenMode: ["synaptic", "plan"]
priority: 60
---

Use `unknown` over `any` in catch blocks.
Prefer composition over inheritance for services.
Avoid default exports — always named.

Drop the file at .synaptic/rules/<name>/RULE.md in your workspace, save, and SYNAPTIC will auto-inject the body into the system prompt for every cycle whose context matches the conditions. Omit whenFilesMatch or whenMode to match anything. Higher priority rules are injected first when the budget runs out.

Discoverability without ceremony:

Above the prompt input, a subtle indicator shows N rules active for the most recent cycle. Click to see which rules fired + a popover with each rule's details.
The sidebar Quick Actions has a Rules button that opens a modal listing EVERY authored rule (matching or not), with filter tabs (All / Matching / Workspace / Legacy), click-to-open for source files, and one-click + New Rule to scaffold a fresh one.
The command palette has SYNAPTIC: New Rule / Open Rule / Reload Rules for keyboard users.

Workspace rules live in your repo and travel with the project — commit them to share with the team, or .gitignore them for personal use. The folder ships with no built-in rules; the maintainers will only add ship-time defaults if marketplace users report concrete demand. See the changelog for the field-monitoring policy.

If you used the slash-skill catalog of 0.10.x (/audit-strict, /decision-gate, etc.) — those are gone in 0.11.0 (the model didn't see real adoption). Any .synaptic/skills/<name>/SKILL.md files you authored keep working through 0.11.x as legacy rules; migrate them to .synaptic/rules/<name>/RULE.md before 0.12.0.

Meet your project Companion

Beyond the main protocol, SYNAPTIC ships with a Companion — a named, opinionated assistant that lives alongside your workspace.

Each session you get one of five personalities (Nyx, Pip, Mux, Zig, or Syn) with their own expressions and tone. The Companion isn't there to write your code. It reads your project's context — the decisions you've made, the path you're on, the questions you've asked — and offers grounded perspective when you ask for it. It has a personality. It can disagree with you. It remembers what you told it across the conversation.

Some users treat it as a rubber duck that talks back. Others use it to second-guess a Decision Gate before committing. It's playful, but it isn't a toy — it carries the same project memory the main agent does, which means its opinions are anchored in your actual work, not generic advice.

The Companion uses your main provider and does not consume cycles.

Plans

Plan	Cycles per month	Price
Free	25	$0
Pro	400	$20/mo
Full	Unlimited	$100/mo

A cycle is one complete prompt → response interaction. Every plan ships with the same features — only the monthly volume differs. Quota resets on the first of each calendar month.

What's new in 0.16

0.16.16 — Cycle boundary state machine closes Finding #43

Post-cycle discipline safety. The extension now models each cycle as a state machine (NOT_STARTED → IN_PROGRESS → SHIPPED | ABORTED | FAILED) instead of an implicit "cycle counter that bumps optimistically when the LLM finishes talking". The counter (session.cycle + monthly quota) increments ONLY when a cycle transitions to SHIPPED, gated on Grade + commit + push all succeeding — an aborted cycle no longer silently consumes a quota slot. In parallel, the Bash tool refuses destructive git ops (--force, --force-with-lease, --amend, git checkout HEAD -- <path>) whenever the boundary is SHIPPED — REGARDLESS of dangerously_allow_all or synaptic.bashTool.allowAllCommands, because the boundary invariant is not an allowlist entry: if the productive commit already landed and the LLM keeps issuing destructive ops, that's the exact runaway pattern surfaced in cycle 109 (~$5-10 API burn on post-commit churn). The four sub-symptoms of Finding #43 documented in DG-G — no post-commit stop, optimistic counter without rollback, fire-and-forget quota recording, no discipline guard on --force/--amend post-cycle — are all closed by the same one abstraction. No UI change; the machinery activates on the first prompt after install. Users who want to audit the pattern can grep the VSCode Developer Console for the prefix [DG-H Finding [#43](https://github.com/golab-arch/SYNAPTIC_VSC_EXTENSION/issues/43)].

0.16.15 — Bash tool guardrail bypass is now logged for audit

Follow-up minor patch to 0.16.14. When synaptic.bashTool.allowAllCommands: true combines with a tool call passing dangerously_allow_all: true, the Bash tool skips BOTH the top-level allowlist check AND the DG-325 destructive-git guard — intentional design (opt-in per workspace + opt-in per call), but previously silent. MotorRLM's cycle 71 (2026-08-28) had git commit --amend --no-edit && git push origin master --force succeed under this bypass; VALIDATION FIRST confirmed the DG-325 regex correctly matches the command — the bypass happened upstream because both bypass conditions were true. DG-F adds a console.warn inside the guard's else branch with a greppable prefix [DG-F Finding [#42](https://github.com/golab-arch/SYNAPTIC_VSC_EXTENSION/issues/42)] including both bypass condition values and the exact command string. Users can grep the VSCode Developer Console for the prefix to audit every bypassed command in the current session. Zero behavior change to the guarded path: when either bypass condition is false, DG-325 fires exactly as before. Users who want stricter defaults can unset synaptic.bashTool.allowAllCommands in their user profile and enable it per-workspace only when needed.

0.16.14 — CRITICAL: reconstructOrphans no longer inflates cycle counters

Emergency patch to 0.16.13 after Finding #41 surfaced empirically on real MotorRLM state during v0.16.13 install + reload: INDEX.totalCycles jumped from 70 to 168 (+97 phantom cycles), two ghost tomes (tome-3, tome-4) were fabricated with fake "50 cycles, 50 successful" narratives and empty cycles: [] on disk, and session.json.currentCycle inflated to match. Root cause: DG-323 reconstructOrphans (v0.16.9 orphan cycle backfill) called the full appendCycle path for every orphan cycleId, which bumps totalCycles++ and currentTome.cycleCount++ and triggers closeTome rotation. DG-310 idempotency only protects against re-appending a cycleId ALREADY in CURRENT.md — any cycleId that dropped from CURRENT.md (transient write failure, manual edit, migration artifact) would get "reconstructed" on the next Initialize and re-bump counters. Cascading across multiple reloads and tome rotations, real cycles double-count and closeTome fires on inflated counts, materializing empty ghost archives. Fix extracts a private appendCycleToCurrent(paths, cycle) helper — CURRENT.md-only write with DG-310 idempotency, returns whether the entry was new. appendCycle calls the helper and bumps counters only on new entries. reconstructOrphans calls the helper directly — reconstructed cycles still appear in CURRENT.md labeled **Agente**: reconstructed (DG-323 behavior preserved) but never touch counters, tomes, or metrics. Reconstruction is surface-level replay of already-counted work; counting it again inflates. Projects with existing damage need manual surgical restore of INDEX.json + affected tome files — the fix prevents future inflation but does not rewind past.

0.16.13 — Bash tool ergonomics: env-var prefix syntax + explicit cwd/state contract

Follow-up patch to 0.16.12 with the pre-announced Bash tool ergonomics batch. The Bash tool now accepts POSIX env-var prefix syntax. MotorRLM Cycle 43 tried to run MOTORRLM_JOBS_POSTGRES_URL="postgresql+psycopg://motorrlm:motorrlm_dev@localhost:5999/motorrlm" uv run python -c "…" and got rejected because the allowlist checker did split(/\s+/)[0] on the raw string, tokenized on whitespace INSIDE the double-quoted URL value, and extracted a fragment as the "command name". validateCommand now recognizes the POSIX KEY=value [KEY2=val2 …] command shape (with unquoted, single-quoted, or double-quoted values — spaces ok inside quotes, mixed-case names accepted since Python/Node scripts routinely export lowercase) and runs the allowlist check against the actual command word AFTER the prefix. The DG-325 destructive-git guard still scans the raw command for chained destructive patterns, so MYVAR=x git reset --hard is still rejected. The Bash tool description now documents its cwd/state contract explicitly. Finding #20 (agent chains cd A && cmd A/x where the second reference to A no longer resolves relative to post-cd cwd, or assumes a cd in one call carries over to the next) was reclassified during VALIDATION FIRST: sub-problem 1 is user error (shell handles cwd correctly within a single pipe), sub-problem 2 is design (spawn per call with cwd=workspaceRoot, deterministic). Neither is fixable by code without inventing a false invariant. The elegant fix is to make the contract explicit in the tool description so the LLM reads it and adjusts. The description now names the cwd invariant, warns about the cd A && cmd A/x double-nesting trap by example, and calls out that env-var prefix syntax is supported. Ships with a static smoke that extracts the runtime's own env-prefix regex from source so the test and the runtime can never drift.

0.16.12 — Tome shell invariant, consolidated and actually working

Follow-up patch to 0.16.11 with one MotorRLM dogfooding fix — the last item on the ledger that was flagged as "broken-despite-ship". Version 0.16.8 tried to guarantee that every open tome referenced by INDEX.json also had shell files on disk (so tools iterating INDEX.tomes[].jsonPath didn't hit FileNotFoundError before the tome eventually closed 50 cycles later), but MotorRLM's cycle 66 surfaced tome-002.json referenced in the index and never materialized. VALIDATION FIRST found the smoking gun: writeTomeShell itself was correct — a direct call on MotorRLM's real state materialized the file in one invocation. The bug was in the two layers of code that surrounded it. The initializeBitacora block ran BEFORE INDEX.json creation on first Initialize (so getIndex() returned null and nothing happened), and only ever iterated tomes[0] (so on later Initialize calls in migrated projects, later tomes were silently skipped). The appendCycle hot-path backfill loop ran on every cycle append but did nothing for MotorRLM's 20 real cycles — likely a Marketplace staleness gap or an upstream silent .catch(...), but pure hot-path defense that doesn't defend is parche either way. Both layers are now replaced by a single call inside initializeBitacora (after INDEX.json creation, iterating ALL non-closed tomes) via a new private helper ensureAllTomeShells. writeTomeShell stays idempotent so closed-tome archives are never overwritten; closeTome's own shell materialization for the just-rotated tome (empirically correct) is unchanged. appendCycle loses its 9-line backfill loop and becomes pure append — zero hot-path overhead. Net change: −3 LOC, meaningfully more coherent architecture. Existing broken projects self-heal on the next VSCode reload. Ships with a functional smoke that reproduces the exact MotorRLM cycle 66 state and asserts both materialization AND idempotency (closed tome-001 files must NOT be touched, pre-existing shells must NOT be overwritten).

0.16.11 — Three papercuts closed: allowlist, encoding, and roadmap index drift

Follow-up patch to 0.16.10 with three MotorRLM dogfooding fixes. The Bash tool allowlist now includes file, printf, sed, and awk. Agents needing these were falling back to uv run python -c "…" workarounds — ~500ms/op overhead across cycles. All four are POSIX-standard: file and printf are pure read/stdout; sed and awk become destructive only via explicit flags (-i, output redirect), the same command-level (not flag-level) trust model that already governs rm, mv, cp. A recalibration during the fix showed that python/python3 — previously suspected as blocked — have always been on the allowlist; the "Python was not found" errors were the Windows Store shim intercepting bare python when no real interpreter is installed, not an SVE gap. Python child processes now emit UTF-8 on stdout/stderr regardless of platform. Third empirical repro of the em-dash garble ("em-dash: —" coming back as "em-dash: ΓÇö" on Windows because Python defaults to cp1252) — the Bash tool's spawn now sets PYTHONIOENCODING=utf-8 in its env, placed after the process.env spread so SVE wins over whatever the user's shell exported. PYTHONUTF8=1 deliberately NOT set (it alters filesystem encoding and open() defaults beyond IO — risks breaking scripts that assume locale=C). Cross-platform, no Windows-only branch. Roadmap INDEX.json auto-reconciles at read. When an agent edited an individual NNNN-slug.json (changing status, title, or dependsOn) without triggering a rescan, INDEX.json used to drift silently — MotorRLM's 0006 orchestrator sat as ACCEPTED in the index long after its file was IMPLEMENTED. RoadmapInitiativeService.getIndex() now re-derives volatile fields from individual files on every read, mirroring the DG-313 pattern that keeps INDEX.totalCycles in sync with tome[].cycleCount. In-memory only (no hot-path write); the on-disk snapshot updates on the next explicit scanInitiativesFolder() — an intentional discipline that keeps read latency untouched. As a side benefit, agent-invented off-schema fields (MotorRLM's INDEX had priority, criticalPath, parallelStreams — none of them in the InitiativeIndexEntry interface) stop leaking to callers.

0.16.10 — Agent no longer holds the "delete everything" lever unattended, and its learnings decay

Follow-up patch to 0.16.9 with two agent safety fixes. Destructive git operations now need an explicit user opt-in. The Bash tool has always shipped git on its allowlist because most git subcommands are safe (status, log, add, commit, push, pull — daily-workflow stuff), but that also let the model run git reset --hard, git checkout -- <path>, git branch -D, git push --force, git clean -f, git rebase -i, and git filter-branch unchallenged. A real recovery loop during MotorRLM dogfooding showed how close that comes to destroying uncommitted work. Now those eight destructive shapes get rejected with a clear error that points to the dangerously_allow_all bypass — chained commands are split so a destructive op after a safe prefix still gets caught. Legitimate flows stay allowed: git checkout <branch>, git checkout -b <new>, git rebase main (non-interactive), git reset HEAD~1 (soft default), git clean -n (dry-run), git push origin main (no force). The learning system stops accumulating noise. Trivial titles like "Project uses Python" or "Project has dedicated test directory" (every project uses SOMETHING) get filtered before they ever reach INTELLIGENCE.json, and any learning that hasn't been reinforced in 30 days gets archived regardless of its score — closing the trap where an old "Compliance trend Grade D over cycles 34-35" entry kept getting re-reinforced long after those cycles became history and dominated the system-prompt injection.

0.16.9 — Cycles that never made it into the bitacora are now backfilled from raw logs

Follow-up patch to 0.16.8 with a single fix that closes the bitacora subsystem findings from MotorRLM dogfooding: some cycles ran successfully in older SVE versions but never landed in bitacora/CURRENT.md because a silent .catch(...) (removed in v0.16.6) swallowed the failure — the cycles' full LLM responses were still logged to .synaptic/bitacora/responses.jsonl, they just weren't in the markdown archive that SearchBitacora and Architect Mode read from. Initialize now runs a one-shot backfill that reads responses.jsonl, notices any cycleId missing from CURRENT.md, and synthesizes an entry with the raw log's fullResponseText preserved. The synthesized entries are marked with _reconstructed: true and a note explaining which fields couldn't be recovered (prompt, decision gate, metrics — those were never in the raw log), so consumers can filter them if they only want the live-written subset. Cycles that don't appear in responses.jsonl at all remain unrecoverable — nothing is fabricated. Wrapped in try/catch so a corrupted raw log can't block Initialize. Together with the dual-writer split in 0.16.6, the history transition normalizer in 0.16.7, and the tome shell materialization in 0.16.8, this closes the ten bitacora subsystem findings that MotorRLM surfaced.

0.16.8 — Tome archive files exist from day one instead of lying about it

Follow-up patch to 0.16.7 with a single structural fix: when the SYNAPTIC bitacora subsystem rotates from one tome to the next (every 50 cycles), the new tome's entry was pushed into INDEX.json.tomes[] with a jsonPath pointing to tomes/tome-XXX.json — but that file was never materialized on disk until the tome itself eventually closed 50 cycles later. External consumers that iterated the index and tried to open the file (a Python script inspecting the archive, SearchBitacora spanning historical tomes) hit FileNotFoundError on any currently-active tome. Now Initialize materializes tome-001's shell right away, tome rotation materializes the new tome's shell in the same operation as pushing the INDEX entry, and every cycle runs a defensive backfill pass so projects provisioned before this release get the missing shells on their next cycle without needing to re-Initialize. Shells are honest empty-cycle placeholders — they get overwritten with the real archive content when the tome eventually closes.

0.16.7 — Roadmap history no longer conflates real transitions with reaffirmations

Follow-up patch to 0.16.6 with a single read-side fix: initiatives' history[] array in .synaptic/context/roadmap/*.json used to read as ACCEPTED, ACCEPTED, ACCEPTED, ACCEPTED, ... — 8+ entries all recording the same status — because the writer (an agent, via the Write/Edit tool) appended a new entry every cycle it touched the initiative, not only on real state transitions. SVE's own Architect Mode couldn't tell which of those were the real transitions and which were reaffirmations, so it misread the roadmap when asked "what happened at cycle X". Now, when the roadmap store reads an initiative, it derives a transition field per history entry — "initial" for the first entry, "advanced" when the status differs from the previous entry, "reaffirmed" when it matches. On-disk data is never modified — the enrichment is added in memory at read time — and consumers that want only the real state changes can filter entry.transition !== 'reaffirmed'. The dual-writer companion (Finding #30 in v0.16.6) plus this schema-side pass close the two structural bitacora findings that made SVE confuse itself during dogfooding.

0.16.6 — Only one bitacora writer now, and it's the one you thought was writing

Follow-up patch to 0.16.5 with a single structural fix: the SYNAPTIC bitacora subsystem used to have two writers firing on every cycle, one to .synaptic/BITACORA.md (legacy) and one to .synaptic/bitacora/CURRENT.md (the canonical file consumed by SearchBitacora and by SVE's own Architect Mode self-consultations). No invariant enforced they stayed in sync, and the canonical writer was wrapped in a silent .catch(...) — so when it failed silently (a filesystem race, a not-yet-initialized index), the legacy writer succeeded alone and the cycle content ended up in the wrong file. The symptom in a real project (MotorRLM) was a 6-cycle gap in CURRENT.md where cycles 57-62 lived only in the legacy file — SVE couldn't find its own recent history when the user asked about those cycles in Architect Mode. The dual-writer path is gone: bitacora/CURRENT.md is now the single canonical writer, fresh projects no longer get a .synaptic/BITACORA.md at all, and reading fallback (CURRENT → legacy → none) means existing projects with the legacy file lose nothing. Silent bitacora failures now propagate to the outer catch so they show up in the Extension Host log instead of vanishing. A companion release (0.16.7) will add the migration that merges orphaned cycles from any existing legacy file into CURRENT.md — until then, existing content stays on disk and readable.

0.16.5 — Bitacora accounting self-heals, backups stop cluttering your git status

Follow-up patch to 0.16.4 bundling three fixes from MotorRLM dogfooding cycles 39-63. The "total cycles" counter in your BITACORA index no longer drifts from reality — a symptom we saw where the counter would silently undercount by several cycles over long sessions (typically when a background operation failed with no visible error) is now self-correcting: every read re-derives the number from the underlying per-tome counters and logs a warning if it had to correct anything, so the drift becomes visible when it happens instead of masked. INTELLIGENCE.json backup files no longer clutter git status on every cycle — SVE creates a timestamped backup before each cycle-close mutation, and the old retention (10 files) meant every cycle was already at capacity so every cycle produced a delete + create pair in your git status, burying real work. Retention bumped to 50 (still trivial on disk) and Initialize now creates a .synaptic/.gitignore that excludes both backups/ and SYNAPTIC_AUDIT/ from your git repo automatically. Existing projects with previously-tracked backup files need a one-time git rm --cached .synaptic/backups/*.json && git rm --cached .synaptic/SYNAPTIC_AUDIT/*.json && git commit to apply the new exclusion — CHANGELOG has the exact commands. Fresh workspaces need nothing. A .synaptic/.editorconfig file now declares the UTF-8 charset for all SYNAPTIC-managed files so editors that honor EditorConfig (VS Code, JetBrains, Vim) open them with the correct encoding on Windows — Python users still need to pass encoding='utf-8' when calling open() explicitly, but the editor surface is now consistent.

0.16.4 — Three papercuts from real dogfooding, silently fixed

Follow-up patch to 0.16.3 bundling three fixes from MotorRLM dogfooding cycles 6-62. Initialize now warns you when your project already has a DESIGN_DOC.md at the workspace root — previously, the extension created its own .synaptic/DESIGN_DOC.md template while the agent's later edits to the root file got blocked by DG-252a (director-file guard), and the whole mid-cycle stall came as a surprise. You'll now see a VS Code toast at Initialize time recommending you rename your file to ARCHITECTURE.md (or another non-colliding name); if you happen to be on a root-layout project, Initialize also refuses to overwrite your existing file. The bitacora writer no longer accumulates duplicate ## CICLO: N blocks when the same cycle gets persisted twice (typical during git commit --amend sequences) — it now replaces the block in place and skips the counter increment, quietly fixing one contributor to the "total cycles" counter drift that older sessions may have accumulated. The Git Cycle History panel no longer treats DG-NNN references inside commit bodies as fake cycles — a docs commit that mentioned (DG-299) used to sort to the top of the panel as "Cycle 299", masking your real project history; the parser now only matches the canonical [SYNAPTIC] DG-NNN: prefix at the start of the commit subject.

0.16.3 — Grade F auto-commit hotfix: the safety net actually fires now

Follow-up to 0.16.2. The auto-commit that saves your work when a cycle ends with Grade F used a git pathspec (":(exclude).vscode/synaptic") to skip the chat-history folder — but git aborts with a fatal error when that path is also in .gitignore (the SYNAPTIC-project convention). So in the exact scenario the fix was designed for, the commit never landed and the promised "your work is preserved in commit <sha>" message never appeared — silently broken. Worst case, the abandoned git add left files staged that the user then had to git reset HEAD manually. This release drops the pathspec entirely (letting .gitignore do its job) and adds a defensive second-layer git reset for .vscode/synaptic in case the project's .gitignore doesn't list it. Surfaced in a real dogfooding session on 2026-08-25.

0.16.2 — Grade F now preserves your work, and Edit no longer chokes on CRLF vs LF

Two quality-of-life fixes from real project use. Grade F cycles now leave your work in a real commit you can inspect. When a cycle fails enforcement badly enough that it isn't counted, any files the agent already wrote during those attempts used to just stay in your working tree with no marker — silently mixing into your next cycle. Now the extension auto-commits those changes with a distinctive message (Grade F preserved (N attempts): cycle not counted — review before next cycle) and shows you the commit's short SHA with concrete recovery instructions: git show <sha> to look at what happened, git reset --hard HEAD~1 to throw it away. If auto-commit itself fails (no repo, signing key missing, hook rejects) the cycle still ends cleanly — the safety net just isn't there for that one case. The Edit tool no longer silently fails when line endings don't match. A Windows-CRLF file edited with a pattern the model emitted in LF (or the reverse) used to return a blank "old_string not found" error with no hint that line endings were the cause; the agent burned tool iterations debugging it. Byte-exact match still wins first (fast path, no change if your pattern is correct); on miss, the tool now retries with line endings normalized to whatever the file uses, and if that succeeds it writes back preserving the file's original endings byte-exact — no cross-EOL mix, no corruption. When neither works, the error explicitly names the line-ending mismatch as a likely cause.

0.16.0 — Roadmap view now shows what depends on what

The Roadmap tab in the Maps panel used to lay out every phase across every initiative in a single vertical chain — with 10 initiatives × several phases each, that meant a ~2000px column that was unreadable at scale and, worse, actively misleading (it suggested strict sequential ordering when in reality several initiatives can proceed in parallel). The new layout renders one compact group per initiative (its phases stacked top-to-bottom), and connects the groups with real dependency edges derived from each initiative's dependsOn. Initiatives that share a prerequisite without depending on each other lay out side by side automatically — no schema tweak needed, the parallelism is just what the DAG says. Terminal states (rejected / archived / superseded / deprecated / obsolete) are dropped whole to keep the view about what's actually in play. Phase colors and the "You are here" marker on the current in-progress phase are unchanged. Projects that haven't proposed any initiative yet still see the previous linear timeline — the old layout is preserved as a fallback and picked automatically based on the workspace shape. This whole change was scoped, sequenced, and validated by dogfooding the extension on a fresh greenfield project; the field-finding it closes was tracked openly (Finding #17 in the accompanying findings log).

What's new in 0.15

0.15.2 — Bugfix batch surfaced by real project use

Seven small-to-medium issues collected across two days of using SYNAPTIC on a real greenfield project (a fresh RLM engine implementation, not a synthetic smoke test) shipped as one patch release. The most user-visible: phases marked IMPLEMENTED in an initiative now correctly count as done and render in green in the Maps panel — the earlier counter and colors only recognized the older COMPLETED literal, so a project with real completed work was showing "0 of 44 phases complete (0%)" while the JSON said otherwise. Phase node labels now also show each phase's own title (was previously showing the parent initiative's title repeated on every node), and the per-phase sublabel is status-aware ("done cycle N", "in progress", "blocked") instead of the uniform, useless "cycle 1+".

Under the hood, three fixes address friction the agent itself was hitting: Windows Git Bash paths now resolve correctly when the agent copies pwd output into a Write/Read/Edit call (/d/foo/bar was being interpreted as C:\d\foo\bar and files landed in a stray tree), the Bash tool now auto-retries git commands on the transient Permission denied on .git/objects race that hits when the extension's runtime state writes overlap with an agent-issued commit on Windows, and the Bash whitelist grew five harmless POSIX commands (date, cd, echo, which, command) that the agent was previously working around every cycle. Finally: Plan-mode cycles are now recorded in the cloud — a Cloud Function enum check was silently rejecting mode: "plan" in production (the source-side fix has been in the repo since May but wasn't redeployed until this release), so Plan-mode telemetry has been missing from analytics for months.

Full field-findings ledger with reproduction steps, severity, and root-cause hypotheses maintained during the dogfooding run — no synthetic bugs, no hand-crafted repros, everything surfaced from real work.

0.15.1 — Maps panel crash fix for initiatives with a non-standard shape

If an initiative got created with a field missing or shaped differently than expected (for example, no dependsOn list at all), opening the Initiatives tab could blank the entire Maps panel with no error message — not just fail to show that one initiative. Both Maps views (the dependency graph and the per-initiative lifecycle history) now tolerate missing or unexpected fields instead of crashing, and the agent's own instructions for creating a new initiative now include the exact field shape to write, reducing how often this can happen in the first place. If you hit a blank Maps panel on 0.15.0, this release fixes it — no data was lost, and nothing needs to be redone.

0.15.0 — Roadmap as a graph of initiatives, plus smarter output-token budgeting

Your roadmap is now a graph, not a list. Previous versions tracked project roadmap as one linear file — fine for a small project, dishonest once real work has several initiatives running at once: a migration in progress, a feature that depends on it, a redesign that replaces an older one. Each initiative now lives in its own record with a real lifecycle (proposed, accepted, in progress, blocked, implemented, archived, superseded, deprecated — ten states, in the spirit of Architecture Decision Records: nothing is silently edited away, a change of direction is a new state with a reason, not a rewritten history) and two kinds of relationship to other initiatives: what it depends on, and what it replaces.

Two new views in the Maps panel's Initiatives tab: a dependency graph (what's blocking what, what replaced what) and, one click into any initiative, its full lifecycle history — every state change, when, and how it happened.
Traceability that reaches into your project's archive. Click a point in an initiative's history and the question opens in Architect Mode, grounded in your real project record — including history old enough to have rolled into long-term archive. Validated against a real 341-cycle project: asked about cycle 1 from a project currently 340 cycles past it, retrieved the exact original prompt and cross-referenced the actual document it had reviewed that day — not a guess at what probably happened.
The assistant won't quietly duplicate an initiative. Before proposing a new one, it reads what already exists; if something similar is already tracked, you get a real Decision Gate — create it anyway, fold the request into the existing initiative, or skip it — instead of two initiatives silently drifting apart. A second, code-level check blocks an exact or near-exact duplicate from being written even if that step is somehow bypassed.
Hardened against several edge cases surfaced by real use before this release shipped: data the model wrote in a slightly wrong shape, a status value outside the fixed vocabulary, a relationship that needed to point at more than one other initiative at once — all now handled defensively (shown clearly, never a crash) rather than assumed away.

Output token budgeting, the other half of context engineering. Most of the current conversation about context engineering is about what goes into a model's context window. This release addresses what comes back out. The output ceiling per response is now raised across every API provider (matching the level already proven safe for Google Gemini, where the same class of issue was found and fixed earlier), user-configurable via synaptic.maxOutputTokens for anyone running larger tool-heavy cycles, and monitored proactively — if a response uses most of its budget without actually being cut off, you get a quiet heads-up before it becomes a real truncation. Also fixed: a cycle that completed real file changes but ran out of budget writing its own closing summary used to read as a silent failure ("the model may have failed silently, try again") — it now tells you plainly that the work was applied and offers to continue for the summary.

0.14.1 — Decision history now actually tracks what you decided

Every Decision Gate you resolve by clicking an option — the normal way most people use them — now gets properly recorded in your project's decision history and becomes searchable through long-term project memory. This was silently broken before: the gate worked, your choice took effect, but the record of what was decided never made it into history. Also fixed: a rare case where a Decision Gate could be followed by a completely empty, silent response if the model's next turn hit its own output limit — you'll now get a clear message telling you to ask it to continue instead of wondering if anything happened.

0.14.0 — Long-term project memory search

Project history now reaches further back than the current session. Once a chunk of history rolls into the project's long-term archive (roughly every 50 cycles), asking about it — "why did we choose Redis for sessions?", "what happened in cycle 33?" — retrieves the actual decision and outcome instead of forcing a manual search through old files. Works in SYNAPTIC, Architect, and Plan modes. Validated end-to-end against a seeded project history with a real model: correctly retrieved a multi-cycle-old architectural decision by topic and a past failure by cycle number, and correctly stayed silent on unrelated questions. Not available with local CLI providers (Claude Code CLI, Codex CLI, Gemini CLI) or in the Companion Assistant, for the same reasons other agentic tools already aren't. No embeddings or external search index involved — retrieval runs entirely on your local project files, consistent with SYNAPTIC's no-proxy design.

What's new in 0.13

0.13.2 — Privilege-operation classifier no longer blocks pasted output

Pasting terminal output that mentioned "sudo" (an install log, an error you were asking about) used to be treated the same as an instruction to run a privileged command, blocking the cycle outright. Real privileged execution is independently blocked at the tool layer regardless of chat text, so this specific detection no longer hard-blocks — it now shows a short non-blocking notice instead, and every other protocol check (forced push, forced install, dynamic code execution) still blocks exactly as before.

0.13.1 — Architect and Plan Mode conversation continuity

Architect Mode and Plan Mode now keep their own short conversation buffer, separate from SYNAPTIC mode's. Previously, asking either mode to "continue with what you proposed" left the model with no memory of its own prior turn in the conversation — it either searched back through the project log to reconstruct context, or answered without it. Validated via real dogfooding on a live project: a follow-up Architect turn that previously required extensive file search to recall its own proposal now resolves immediately, because the context is already there. No change to SYNAPTIC mode's existing behavior.

0.13.0 — Audit Report Export

A new Export button in the Audit tab produces a navigable Markdown report from your project's provenance log, at three depth levels:

Executive Snapshot — 1-page plain-text summary, no LLM, instant.
Auditor Report — multi-section narrative across selectable lenses (Forensic, AI Governance, Quality Control, Productivity Metrics, Cost & Model Optimization, Supply Chain), plus a Recommendations section.
Forensic Dump — raw records with a minimal header, no narrative.

All numeric metrics, percentages, and rankings in the report are computed deterministically in code — the LLM only narrates, it never fabricates figures, and every narrated section ends with a disclaimer citing the model used. The report also distinguishes "apparent quality" (raw success rate) from "effective quality" (excluding SYNAPTIC's own protective rejections, like blocking a test-fabrication attempt), so a rejection SYNAPTIC caught on your behalf doesn't read as the system failing.

This release also fixed Decision Gate linkage in the provenance audit trail: edits that implement a decision you made at a Decision Gate are now correctly attributed to that gate, so the Audit Report's "Decision Gates linked to file edits" metric reflects reality going forward. Records logged before this fix are not backfilled.

What's new in 0.12

0.12.0 — Three new providers (Qwen, DeepSeek, Kimi)

0.12.0 ships three new API providers for users who want broader model choice — bringing the total to eight API providers plus three local CLIs. All three are OpenAI-compatible drop-ins (you paste your API key, pick a model, prompt as usual), and all three were validated against SYNAPTIC's protocol with empirical smoke testing before this release.

Qwen (Alibaba) — Qwen3-coder-next family via DashScope International. Default model qwen3-coder-next (262K context window, function calling). Get your API key at modelstudio.console.alibabacloud.com.
DeepSeek — V4 Pro (capability) and V4 Flash (cheap). Default model deepseek-v4-pro. Get your API key at platform.deepseek.com.
Kimi (Moonshot) — K2.7-code family. Default model kimi-k2.7-code ("Kimi's strongest Coding model"). K2.7-code-highspeed available as a speed-optimized variant. Get your API key at platform.kimi.ai.

Transparency note on Qwen tool-use

To get the most consistent SYNAPTIC protocol engagement with Qwen — Decision Gates rendered as interactive UI cards rather than markdown text — the extension automatically appends a short tool-use instruction to your prompt when Qwen + SYNAPTIC mode + tool migration are all active. Empirical smoke testing showed Qwen needed this nudge to invoke protocol tools natively; DeepSeek and Kimi did not. The injection is logged to console ([DG-265] Qwen tool-use augmentation injected ...) and can be disabled via the setting synaptic.qwen.toolUseAugmentation.enabled if you prefer manual prompt control.

The equivalent settings for DeepSeek and Kimi (synaptic.deepseek.toolUseAugmentation.enabled / synaptic.kimi.toolUseAugmentation.enabled) ship disabled because those providers engage with SYNAPTIC tools natively without it. They exist as opt-in for advanced users who want extra reinforcement.

What's new in 0.11

0.11.0 — Project Rules (replaces Skills v2)

0.11.0 replants the slash-skills feature of 0.10.x into a Cursor Rules-style auto-injection model. The headline change: stop asking users to remember /audit-strict and start letting them write their project conventions once and have the agent follow them automatically.

Project Rules — drop a Markdown file at .synaptic/rules/<name>/RULE.md with a short YAML frontmatter (which files / modes it applies to + a priority) and a body in plain prose. The agent auto-injects matching rules into the system prompt for every cycle whose context matches the rule's conditions.
Active rules indicator — a subtle badge above the prompt input shows N rules active for the most recent cycle. Click to see each rule's name, tier, priority, and description. Renders nothing when zero rules match (zero footprint UX).
Rules browse modal — a Rules button in the sidebar Quick Actions opens a modal that lists EVERY authored rule, not just the matching ones. Filter tabs cover All / Matching / Workspace / Legacy; click any card to open its source file. Footer buttons trigger + New Rule and Reload.
Three palette commands: SYNAPTIC: New Rule (scaffold), SYNAPTIC: Open Rule (quick-pick), SYNAPTIC: Reload Rules (manual reload — the file watcher also picks up changes with 300 ms debounce).
Migration note for 0.10.x users: the slash commands (/audit-strict, /decision-gate, /explain-bitacora, /sync-intelligence, /skills, /reload-skills) are gone — the prompt forwards verbatim now. Existing .synaptic/skills/<name>/SKILL.md files keep working through 0.11.x under a compat layer (loaded as legacy rules, always-on, priority 30, console warning on load). Migrate them to .synaptic/rules/<name>/RULE.md before 0.12.0.

See the dedicated Project Rules section above for a worked example.

Previously

0.10 highlights — Init Gate (opt-in workspace model so SYNAPTIC doesn't stain unrelated projects), monthly quota with subscription tiers, eight providers at the time (Codex CLI and Gemini CLI added — Qwen, DeepSeek, Kimi arrived in 0.12.0), Save Progress (commit + optional push without consuming a cycle).

0.9 highlights — Interactive Decision Gates, Plan Mode, in-loop verification (tsc + ESLint with self-correction), anti-hallucination grounding (newly-written code parsed against a real grammar), Audit tab, prompt caching, security & hygiene scan.

Known issues: a few cosmetic UI rough edges in the chat panel and Audit tab are still being polished — functionality is unaffected. The function-calling migration runs in dual-write mode (legacy text path still authoritative for protocol signals).

Getting Started

Install the extension from the VS Code Marketplace
Sign in with Google or GitHub (OAuth PKCE)
Add an API key for your preferred provider (Ctrl+Shift+P → "SYNAPTIC: Manage API Keys")
Open the Chat Panel with Ctrl+Shift+Y (or Cmd+Shift+Y on Mac)
Send your first prompt and start a cycle

Keyboard Shortcuts

Shortcut	Action
`Ctrl+Shift+Y` / `Cmd+Shift+Y`	Open Chat Panel
`Ctrl+Enter`	Submit prompt
`Ctrl+Shift+Enter`	Submit and execute immediately (skip Decision Gates)

Extension Settings

Setting	Default	Description
`synaptic.defaultProvider`	`anthropic`	Default LLM provider
`synaptic.defaultModel`	`claude-sonnet-4-5-20250929`	Default model
`synaptic.toolApproval`	`selective`	Tool execution approval mode (`selective` or `auto-approve`)
`synaptic.agentMaxIterations`	`0`	Max tool iterations per cycle (0 = unlimited)
`synaptic.enforcementBlocking`	`false`	Block non-compliant responses after validation fails (opt-in)
`synaptic.planMode.enabled`	`true`	Enable Plan Mode (the third mode)
`synaptic.planMode.autoBranch`	`true`	Run "Execute Plan" on an auto-created isolation branch (git repos only)
`synaptic.verifier.maxRetries`	`3`	Shared self-correction budget for the `tsc` verifier + ESLint runner
`synaptic.eslint.enabled`	`true`	Run ESLint on the agent's edited files (when the project has ESLint configured)
`synaptic.decisionGate.timeoutSeconds`	`1800`	How long an interactive Decision Gate waits before falling back to text-mode
`synaptic.rules.maxInjectionBudget`	`8192`	Max characters of workspace rules content auto-injected into the system prompt per cycle (range 1024–32768)
`synaptic.budget.*`	See settings	Context injection budget controls

Provider notes

These notes are important if you plan to use a local CLI integration.

Claude Code (CLI)

SYNAPTIC spawns the claude binary as a subprocess and never handles Anthropic credentials directly. Per Anthropic's third-party integration policy, authenticate Claude Code with an Anthropic API key via claude login. Subscription OAuth tokens (Claude Pro, Max, Team, Enterprise) are not permitted for third-party integrations, even indirectly via subprocess.

Codex CLI

Codex CLI's default approval/sandbox behavior cancels MCP tool calls mid-execution. To make SYNAPTIC's tool calls work with Codex, the extension spawns Codex with the --dangerously-bypass-approvals-and-sandbox flag. The first time you submit a SYNAPTIC-mode prompt with Codex selected, the extension shows a consent modal explaining what the flag does and why it's needed. Consent is stored per-workspace and can be revoked any time from the chat header.

Auxiliary features (Companion chat, Tech Stack Analyzer, UI Map Analyzer) never use this flag.

Gemini CLI

SYNAPTIC spawns the gemini binary as a subprocess. Authenticate with an API key (GEMINI_API_KEY or GOOGLE_API_KEY env var, set before launching VS Code).

Folder trust: Gemini CLI uses a workspace "folder trust" model for tool access. If tool calls don't work, run gemini interactively once in the workspace and confirm the trust prompt.

Image attachments with local CLIs

When you attach an image and the active provider is a local CLI (Claude Code / Codex / Gemini), SYNAPTIC writes the image to <workspace>/.synaptic-attachments/ so the CLI's internal Read tool can load it. The directory will appear in git status. SYNAPTIC deliberately does NOT auto-add it to .gitignore — Gemini CLI's Read tool refuses to load files matched by any standard git-ignore mechanism. Files older than 24 hours are cleaned up automatically.

If you don't use Gemini CLI and prefer a clean git status, you can safely add .synaptic-attachments/ to your project's .gitignore manually.

Privacy

API keys are stored in VS Code's encrypted secret storage. Never transmitted by the extension itself.
LLM calls go directly from your machine to the provider you selected. No request passes through a SYNAPTIC server.
Project memory lives inside your workspace, in .synaptic/. You decide whether to commit it or gitignore it.
Sign-in via Google or GitHub OAuth (PKCE flow).
The extension records cycle metadata (model used, duration, score) to enforce monthly quota. It does not transmit your prompt content or the model's response.

Requirements

Visual Studio Code 1.85.0 or later
A Google or GitHub account (for sign-in)
An API key from one supported provider, or one of the supported CLIs installed (claude, codex, gemini)

License

MIT — the full source is on GitHub.

Publisher

Built by GoLab — Conexiones Sorprendentes.