Flockion for VS Code — developer preview 0.38.9

A coding workspace connected to a published Flockion agent or internal team. Ask about code, review a plan, or let the agent or team edit files and run commands. The editor tools work across programming languages; ABAP is one specialized agent and customer workflow.

Explore agents, teams and the Flockion platform at flockion.com.

Screenshots

Screenshots show selected extension workflows. Example agent, workspace and task data is illustrative.

Chat and code review	Composer and context

This milestone includes the local editor coding loop. In Act mode, explicitly published backend tools (including configured MCP tools) can run under existing Flockion policy and connections. A local SAP ADT virtual filesystem, SAP activation and ABAP Unit still need real-system acceptance. Direct Jira status synchronization, deployment controls and remote workspace runners remain planned. Independent server tasks can now use Flockion's persisted agent/team worker queue. Installing this extension does not provision an SAP environment or other services.

Production connection and admission

For Flockion Cloud, use https://api.flockion.com/api/v1 as the API base. https://flockion.com serves the website and does not proxy the editor WebSocket. Use the runtime URL displayed under API & editor access. Keep its agent/team ID and existing scoped key when correcting the API hostname. Manual connections now verify the API challenge before sending the key for validation, without starting a model task. The agent chip identifies the configured connection; the live chat socket opens when you send a task.

Account limits apply to the API key owner even when the tester has no Flockion account. If hosted credits are exhausted, the owner must add capacity or configure the agent/team with an owned saved model-provider API key. The runtime API key is separate from the model-provider credential. With the matching backend, terminal admission failures preserve their specific reason and clear the rejected chat's pending state. Interrupted work with an uncertain outcome still requires checking request status before continuing.

Background tasks on Flockion

Open the cloud icon in the header, or Flockion: Background Tasks. Write an independent task or copy your chat draft with Use chat draft, then choose Run on server. Accepted tasks persist in the backend and can execute after VS Code closes. The panel polls for status while open, shows the latest 20 tasks (active first), and provides saved responses, Copy and Cancel queued task. Results are scoped to the same connected runtime credential.

This path uses the agent/team's published model and server tools. It does not inherit the local conversation, files, attachments, queue, model override or Full access setting. Every request has a hard $5 model budget and the connection allows ten active tasks. Independent tasks may run concurrently. The local five-task queue continues to run sequentially in the editor.

The updated backend requires WORKER_AGENT_RUNS_ENABLED=true. Keep its scheduler enabled, or run a separate continuous worker with python -m app.workers.run_worker --loop from backend, using the same database and runtime configuration. The panel reports when the feature is disabled. See the bundled BACKGROUND_TASKS.md for setup and recovery limits.

Progress, clipboard images and browser checks

The conversation shows public work updates that the agent explicitly sends with the editor progress action. Tool calls show their actual inputs, results and durations. The bottom status displays elapsed time and animated waiting labels; it does not invent tool activity or expose private model reasoning.

Paste an image into the composer to upload it with the current scoped runtime credential. A thumbnail and dimensions appear before sending and remain in the saved conversation. PNG, JPEG, GIF and WebP images are accepted, up to four attachments and 5 MB per file. You can send an attachment without typing a prompt.

Use + → Check app with Playwright in the composer to draft a standalone Playwright task, or ask the agent to check an app URL. In Act mode, editor_workspace action browser supports click, fill, press, visible-element and text assertions with CSS/Playwright selectors, up to 15 steps. Review mode shows the URL and steps before execution; Full access follows the existing local authorization setting. Checks use a new browser context in installed Edge/Chrome or cached Playwright Chromium, remain on the approved origin, and do not reuse your signed-in browser. Protected apps therefore require their own test login flow.

Results include screenshots, per-step outcomes and console/network/page errors. Those errors fail the check for review. Screenshots are stored in workspace extension storage, open from the activity log, and are uploaded to the current Flockion attachment store so the agent can inspect the visual evidence. Failed uploads leave local screenshots available and report the upload warning. The backend must include the matching progress/browser editor tool schema.

To use a visible page inside VS Code, choose + → Browser tools (or Flockion: Browser Tools). Open the URL, share the tab with the browser's Share with Agent button, and choose Use VS Code browser in Flockion. The selected agent/team can inspect the page, click, type and capture screenshots through VS Code's public tool API. Alternatively connect the browser tools exposed by a running Playwright MCP server. The providers use their own browser sessions. See the bundled BROWSER_SETUP.md for setup, evidence and session details. This feature requires the matching backend's browser_tools/browser_call schema.

Selected VS Code tools and screen readers

Open + ? Tools and accessibility to search and select registered VS Code, extension and MCP tools, then Apply selection. Selections persist for this workspace and are available to the connected agent/team. Supplementary calls need Act mode and individual review, including Full access; native tool permissions still apply. Some tools require VS Code's own Chat context. Deploy the matching backend to enable vscode_tools / vscode_call.

Screen reader support offers Auto/On/Off. Auto follows VS Code detection. Optimized mode provides polite response/review announcements, reduced motion and stable reading focus. Open readable conversation opens a read-only snapshot in the native editor. See the bundled TOOLS_SETUP.md for setup and compatibility limits.

Jira workflow

For connection setup, read the bundled JIRA_SETUP.md, or expand How to configure Jira in Delivery. Personal Atlassian tokens use the accompanying Basic username/password MCP option; service-account keys use Bearer auth.

Open Delivery to link a Jira key or HTTPS issue URL to the conversation. The reference persists in history, appears in exported transcripts and subsequent task context, and prefills the Jira field in code review forms.

Draft a requirements task to read the issue through the selected agent/team's published Jira tools. Prepare an implementation update from recorded file changes, command/browser outcomes, screenshot count and checklist state, then edit the comment text. You can also draft a Story, Task or Bug with project, summary, description and acceptance criteria. These actions fill the composer in Act mode. Review and Send starts the existing governed runtime; preparation alone does not invoke Jira. Tool activity and the resulting response provide execution evidence.

The selected agent or team needs the appropriate published Atlassian MCP tools and an authorized account connection. Missing tools, ambiguous Jira sites and platform approvals must be resolved in that runtime. The extension does not infer a remote issue status from its local link. Automatic status synchronization, transitions and screenshot attachment publishing remain planned.

ABAP coding agent

The repository includes a private Flockion ABAP Coding Agent starter and the engineering-abap runtime skill. Provision them for an existing account:

cd backend
../.venv/Scripts/python.exe scripts/seed_abap_coding_agent.py --owner-id USER_ID

The seed targets only that agent, skill and workspace tool and is safe to rerun. It uses the owner's saved OpenAI API-key connection when available. You can select one with --connection-id CONNECTION_ID and override the starter model with --model MODEL_ID. No provider credential is stored in the seed YAML. The selected connection must contain a valid provider key; a saved connection's presence does not prove its credential works.

If you updated the local backend/.env key, explicitly rebind this agent with python scripts/seed_abap_coding_agent.py --owner-id USER_ID --use-env-key from backend using the repository Python environment. This saves the key in the encrypted model-connection store and places only its connection ID in the agent. It does not update production or overwrite other agents' connection bindings.

Edit .agents/skills/engineering-abap/SKILL.md to maintain the engineering instructions, then run backend/scripts/build_engineering_abap_skill.py with the repository Python environment to regenerate the deployable skill bundle. The skill covers ABAP language versions, released APIs, CDS/RAP, authorization, ABAP Unit, ATC, object conflicts and transport evidence. It does not grant SAP access or create a development destination.

For a live, read-only fixture test, run:

../.venv/Scripts/python.exe scripts/smoke_abap_editor.py --owner-id USER_ID --agent-id AGENT_ID

Run this from backend. It exposes only an in-memory ABAP fixture, caps the model budget at USD 0.25 and revokes its temporary API key after the attempt. It verifies model/tool connectivity rather than SAP activation or ABAP Unit.

Without an SAP system, start with examples/abap-coding-pilot/README.md in the repository. It includes local linting and a bounded feature exercise. Read backend/DOCS/abap-development-onboarding.md before setting up a BTP trial or assuming that the SAP ADT extension supplies a backend. These repository files are separate from the VSIX package.

Install

1. Deploy/run the backend from this same source revision. Editor WebSockets use /api/v1/api-access/{agent|team}/{id}/editor; uploads use the corresponding /attachments route. The ingress must support WebSocket connections. No new column migrations are needed. Startup creates the editor login grants, account sessions and runtime connection tables through the existing metadata bootstrap.
2. In Flockion, publish an agent or an internal team of native agents using configured function-calling models. Grant VS Code workspace (editor_workspace) to members that need it. Existing agent, skill, organization and tool policy still applies; local_execution can deny it.
3. Sign in from the extension to choose owned assets, or in the asset's API & editor access, create a dedicated API key and copy its runtime endpoint. Team members keep their own roles, skills and model connections; workspace actions identify the member in Activity.
4. In VS Code, choose Extensions → … → Install from VSIX and select flockion-vscode-0.36.0.vsix from this directory (or the CI artifact).
5. Open a trusted local folder. Click the Flockion logo in the left Activity Bar and choose Open Flockion, use the logo in the top-right editor toolbar, or run Flockion: Open Coding Agent. The chat opens in the Secondary Side Bar beside Chat and other coding assistants. If it is hidden, use View: Open View and select Flockion: Coding Agent. Until you connect, the panel shows the Connections view; later, click the agent/team chip below the header.
6. Choose Sign in with browser to connect through your account, or open Use a runtime API key instead. For a key, enter the runtime endpoint, for example https://your-flockion/api/v1/api-access/agent/AGENT-ID/run or https://your-flockion/api/v1/api-access/team/TEAM-ID/run, and the key. HTTPS is required except for loopback development endpoints.

For this local setup, use http://localhost:8000/api/v1; port 8080 serves the frontend. Version 0.28 repairs a saved manual localhost:8080 runtime connection only when credential-free probes confirm an HTML frontend and the expected localhost:8000 backend auth challenge. It preserves the runtime key in SecretStorage. Other ports, remote URLs and account sign-ins are unchanged. If a proxy returns a website instead of JSON, the model menu reports a backend URL diagnostic. Reload the VS Code window after installing extension updates so its view contributions are refreshed.

Every step happens inside the Flockion panel; no prompts open at the top of the VS Code window. The key is passed once to the extension host and stored in VS Code SecretStorage, never in repository settings or webview state. Disconnect removes the local key; revoke it in Flockion to invalidate other copies. Each conversation is separated by API key and editor session ID. Starting a new conversation creates a new session ID. If a saved chat's runtime credential changes, its transcript remains readable/exportable; branch an answer or start a new chat to continue with the new credential.

Sign in and choose assets

Choose Sign in with browser in the Connections view (or run Flockion: Sign In). The server defaults to your last account or connection; choose Change to enter another API base URL (local development: http://localhost:8000/api/v1). The panel shows an eight-character code while your browser opens the configured Flockion site. Sign in there with your usual account, password and MFA, check the code matches and approve. Use Open browser again or Cancel from the panel while it waits. FRONTEND_BASE_URL must point to that site; if the setting contains a comma-separated list, the first entry is used. The backend and frontend need this source revision for the approval route.

The panel then lists your owned agents and teams with search and Agents/Teams filters. Select one to connect. Only published, unpaused assets allowed by the existing ownership and organization policy can connect; others show the reason. VS Code sets up an asset-scoped runtime key automatically; no key needs to be copied. Account and runtime credentials stay in VS Code SecretStorage and are never sent to the chat webview. This editor credential grants discovery and scoped connection setup, not general account administration. Device approval expires in ten minutes, is verifier-bound and can be redeemed once. The editor session lasts 30 days.

Sign out (confirmed in the account card) revokes the editor session and its runtime connections. Manually entered runtime keys are stored separately. If the server is unreachable, the extension clears local account credentials and reports the failed remote revocation; the account keys can be revoked in Flockion's API & editor access. When the 30-day editor session expires or is revoked, the panel clears it and asks you to sign in again.

Workspace participants and handoffs

In Connections, use + beside an agent or team to add it to the local workspace roster (up to twelve). Manual connections also join the roster. Select a participant under Workspace participants to start a new conversation with it. Remove a participant using its adjacent remove button; this only removes the roster entry, not the server asset.

Choose Hand off beneath an answer and pick a participant or another owned agent or team in the panel to pass only its preceding user question and that answer to another agent or team. The source chat stays in History. The target gets an independent runtime session and shares the workspace's current files; enter its next task to continue. The excerpt is bounded while preserving both question and answer. Attachment contents must be attached again for the target. Agent→agent, agent→team, team→agent and team→team handoffs all use this same path. Members inside an existing team continue to use that team's published orchestration. This roster provides explicit handoffs; autonomous cross-team delegation and parallel workspaces are later work.

The target shows who handed off the task and whether it is waiting for your instruction, running, pending, completed or failed. Handoff creates a new saved conversation; it does not launch work until you send the target's next prompt.

File context, plans and task checkpoints

Type @ in the composer (or use the @ button) to search workspace files and add up to five references. After choosing a file, optionally enter one line or a range of up to 200 lines. Flockion reads the selected excerpt when you send and marks it as untrusted source context. Secret, excluded, binary, oversized and unsaved files are rejected by the workspace reader.

For a response to a Plan request, choose Save checklist to keep its list items in that conversation. Check items as work completes; the checklist is saved with local conversation history and exported with the transcript.

Each request records a task checkpoint for file writes made through Flockion's editor tools. In Git repositories, it also captures safe text file changes visible before and after approved commands, including tracked and untracked changes. Open a checkpoint to review its native diffs, untick files you want to keep, and restore the rest. Restore asks for confirmation and proceeds only when every file still matches the version captured by Flockion. This uses VS Code's built-in Git extension. It skips ignored files, binary or oversized files, unsaved buffers, paths outside the workspace and stage-only changes. Git staging and commit state are never restored. Review those separately in Source Control.

Models and context

Choose a model inside the composer next to the microphone and Send button. Its menu opens above the button, supports search and keyboard navigation, and marks the current choice. Custom model or deployment… opens a small form in the same menu; custom IDs still use a saved provider connection.

During file review, Edit proposal lets you revise the proposed contents and preview their diff before Apply. The existing file must still match the version the agent read. The agent receives the resulting hash and checkpoints record the contents actually saved.

Use the model name (or Default) inside the composer to select a catalog model from the published provider connection or another saved provider connection on your account. Custom model/deployment IDs are also supported. The choice is saved with this chat and overrides the next turn without editing the published asset. For teams, it overrides the manager and internal members; external remote agents retain their own model configuration. Changes can be made between turns. Choose Default to return to the asset's settings. Provider credentials stay in Flockion; organization provider policy still applies.

The circle beside the model picker shows estimated context used. Its tooltip shows used/remaining percentages and tokens; it turns red above 50%. Click it to compact older conversation history. The backend summarizes older messages using the selected model while keeping the latest four messages and preserving all original messages in history. Normal provider charges apply, with summarization usage recorded and checked against organization budgets. If summarization fails, the original context stays available.

At 95% of a known model window, the backend automatically compacts saved history before the next turn or after a completed turn. Native tool loops also compact old message/tool groups at that threshold. If the newest prompt still exceeds 95%, the request is stopped with a request to reduce its context. Token counts are estimates; tool schemas and images may add tokens. Models without a known catalog context limit show token counts without a percentage or automatic threshold; manual compaction remains available. Use a backend with the editor model/context endpoints (no database migration is needed).

Configure a coding team

Create and publish an internal team in Flockion, then create a key under the team's API & editor access. Give members distinct jobs such as requirements, implementation, test, and review. Start with sequential handoff so each member can inspect the previous member's result; publish editor_workspace only for members that need local files or commands. The extension shows the member key beside workspace actions. It serializes writes and commands on the shared local workspace to keep reviews and file versions in order.

Use the same setup for Python, TypeScript, Java, C#, Go, ABAP or other supported source files. The connected repository, project instructions, configured skills and approved tools provide the context. For a SAP pilot, bind engineering-abap to the relevant members and configure a real SAP development destination and governed ADT/MCP connection before requesting activation, ABAP Unit or ATC. Without that connection, the team can inspect local ABAP source and run local checks, but cannot claim to have changed or tested SAP backend objects.

Try the first coding task

• Use Ask to explain the project or inspect a file.
• Use Plan to propose an implementation. Ask and Plan cannot run commands or write files, including test commands.
• Use Act on a small disposable repository: “Inspect the greeting function, add a test for an empty name, implement the behavior, then run the tests.”
• Review each proposed edit in the native diff view and select Apply change in the persistent review card in Flockion chat. Deny skips this action.
• Review each command's exact text, working directory and timeout before running.
• View output in Output → Flockion commands and inspect the final answer.

Access starts in Review each time the extension loads. Choose Full access in the composer to authorize local Act writes and commands automatically for the current connection. Full access does not change Ask/Plan limits, key ownership, organization policy or backend tool policy. Local commands run with the VS Code extension host user's permissions and are not sandboxed. Return to Review in the composer whenever you want individual approvals again.

The agent can list/read/search files, inspect diagnostics, propose version-checked writes, and run commands. Reads return hashes; writes need the expected hash or explicit null for a new file. Files with unsaved changes are unavailable. Save them yourself first. Edits are saved so subsequent tests use the changed files. The normal editor undo history remains available. There is no bulk revert button.

Reviews no longer depend on a notification outside the chat. The review card shows the target file or exact command, with a countdown. An unanswered review is denied after 150 seconds. View diff reopens the proposed edit; previewing does not apply it. Closing the connection or selecting Stop cancels review.

Expand Activity to inspect actual tool steps, failures and command results. Responses render Markdown and include Copy response and Copy code controls. Choose Export in the chat header to save the active conversation as Markdown, including tool activity and attachment names; file contents are not embedded. In History, choose Export on any saved conversation to export it without reopening it. Use Branch in new chat below a response to open an independent conversation with only that response and its immediately preceding user question. Earlier edits remain in the shared workspace; attachment contents need to be attached again. Changed files lists the recent 20 files written through editor tools in this conversation; click a path for its initial-to-current diff or Open for the file. Changes made by shell commands or outside the conversation are not discovered in this list. Each file can be restored to its pre-conversation contents with Undo. Flockion asks before restoring and checks that the file still matches its last edit; a later change blocks the undo. Files created in the conversation are moved to the system trash.

The composer remains editable while a task runs. Queue up to five follow-up tasks with their own Ask/Plan/Act modes, attachments and file references. You can attach files or paste an image while the current task runs. Each queued task keeps its context separate from later drafts; file references are read when that task starts. The queue uses the chat's current model and access permissions. The idle Queue button builds a paused batch; Resume queue runs its tasks sequentially. While a queue exists, Enter adds to it. Run now sends your draft first while leaving a paused queue waiting.

Pause waits for the current task to finish. Reorder, remove or edit individual tasks in the queue card. Editing pauses the queue and preserves attachments and references. Failures (including failed/denied tool actions), Stop, disconnect and reopening pause the remaining tasks. After an interruption, check the saved request status, then explicitly Resume; requests are not replayed. Queue removal and the new request ID are saved together before execution. History shows queued counts and keeps unfinished queued conversations during retention cleanup. Tasks run only while the VS Code extension host is open; this is not a durable server worker. Continue drafts a follow-up without overwriting an existing draft. Shift+Enter adds a new line. Scrolling up preserves your position; Jump to latest returns to new activity. The composer draft/mode survive webview recreation.

Select code and run Flockion: Add Selection to Chat to explicitly attach it. Run it again for more ranges or files, or use multiple cursors to add several ranges at once (up to five selections, 30,000 characters in total). Each chip shows the file and line range that will be sent and can be removed on its own. Secret/excluded paths are blocked for file tools. Each turn has a USD 5 hard budget cap and inherits the agent's tool-call guardrail (8 tool calls by default).

Use the paperclip to attach up to four local images, PDFs, DOCX/XLSX/CSV documents or supported text/source files, at 5 MB each. Uploads are tied to the connected API key and sent as attachment references on the next turn. File bytes are not stored in the webview or local conversation history. Extracted text is bounded to 4,000 characters per document and 12,000 characters overall; PDFs are read from the first 20 pages. Scanned PDFs need OCR before their text is available. The chip shows extraction warnings. Explicitly selected files may be outside the workspace, but secret and excluded paths are blocked.

On Windows desktop, click the microphone to dictate one phrase using an installed Windows speech recognizer and the system microphone. Pause to finish; the result is added to the editable draft and never sent automatically. Click again to cancel. This feature uses local Windows speech recognition and stores no audio in Flockion. Microphone availability depends on a Windows speech language, device and OS privacy settings. Other platforms show the feature as unavailable in this preview.

The conversation shows live tool activity and response progress. Answer text is shown after Flockion's existing output validation; raw unmoderated token deltas are not exposed. This preview is not full feature parity with other coding agents.

Conversation history

Use History in the chat header, or run Flockion: Conversation History. Chats are listed newest first with automatic titles, previews, timestamps and message counts. Search titles/previews, reopen a chat to continue it, or use Rename and Delete. Starting a new conversation preserves the previous one. History is local to the VS Code workspace and filtered to the connected agent or team endpoint.

Reopening uses the original runtime session ID and restores messages, tool results, the changed-file baseline and queued tasks. It does not replay commands or edits. Pending sessions display Check status and require the existing request-status lookup before another turn. Continuing backend context also depends on the original runtime API key and backend conversation retention. Drafts and composer mode are kept separately for each chat.

Transcripts are stored as JSON files in VS Code's extension workspace storage, outside your repository. Its workspace state stores a small summary index. The current saved 0.2.0 chat is migrated on first use; chats already discarded by older versions cannot be reconstructed from the extension. The latest 50 chats are retained, with up to 200 message/activity items per chat and the recent 20 changed-file baselines. Unresolved requests are preserved beyond the chat limit. Each message retains up to 12,000 characters; backend runs remain authoritative.

Deleting a chat removes its local transcript, summary and composer draft. It does not undo workspace changes or delete the backend conversation/run records. History is not synchronized between computers. Selecting another chat is disabled while a task runs; stop it first. If a saved workspace folder is no longer open, reopen that folder before continuing the conversation.

Stop and recover

Stop aborts local work, attempts to terminate running command processes and prevents further workspace dispatch. Effects that already happened are retained. The backend may need time to finish recording cancellation of an in-flight model request. Closing VS Code also disconnects local execution.

After interruption/reload, use Check previous request status. The original request ID is retained and never automatically replayed. A request still marked running needs investigation in Flockion; it is not proof that local execution is still active. After a backend crash, a request can remain unresolved. Start a new conversation only after inspecting the actual workspace and prior run.

The extension keeps bounded local conversation history as described above; Flockion retains the authoritative conversation and run events. Pending approvals and processes are not restored across reloads. This milestone does not include an unattended worker or cross-process action recovery.

Use Delivery (pull request icon in the header) to open the Delivery view for the current branch. It shows whether the branch is pushed to origin and whether gh or glab is installed and signed in, using that CLI's existing login. If a pull/merge request already exists for the branch, it shows its number, title and state with a link; otherwise enter a title and an optional Jira issue key, then open the provider's form in your browser. GitLab opens the form as a draft; on GitHub choose Create draft pull request in the form. Check CI status shows the current checks inline (passed, still running or needs attention). Flockion never pushes commits or submits the form. Push through VS Code Source Control first. The Jira section prepares reviewed read/create/comment tasks for the selected agent's published Atlassian tools. Direct ticket synchronization and deployment controls remain planned. Connected agents and teams can still use their configured GitHub and Atlassian MCP tools under the existing Flockion runtime policy.

Execution boundaries

File tools operate within one selected workspace folder. They reject traversal, symlinks/junctions, secret filenames, private keys and common dependency/credential directories. Text files are limited to 200 KB, returned excerpts to 9,000 characters, and searches to 500 files. Generated edits need a pre-existing parent directory. Large files can be read in line ranges. Hidden application directories are not a general-purpose secret classifier: review what you authorize to share.

Commands run on the extension host with your user permissions. They are not sandboxed and can access other files/network resources. A working-directory check is not a process isolation boundary. Use a controlled repository and review commands. Windows desktop VS Code is the validated development target; other platforms/remote hosts need their own acceptance run.

Build and verify

Requires Node.js 22 or later and npm. The packager's Azure identity/UUID dependency overrides are for private offline VSIX packaging; Marketplace publishing auth is not part of this preview.

cd extensions/flockion-vscode
npm ci
npm run typecheck
npm test
npm run package

The package script produces a versioned VSIX. The publisher identifier is a development manifest value; this preview has not been published to a store. The extension is private and no distribution license is assigned yet.

Run npm run test:host for native editor acceptance checks using an installed VS Code. It launches an isolated temporary profile/workspace and verifies activation, real edits, file creation, unsaved-buffer preservation, stale hashes, mode restrictions, secret exclusion and command execution. Set FLOCKION_VSCODE_EXECUTABLE if VS Code is not in the standard Windows location. The temporary test profile is removed after the test process exits. It also checks the real chat host against a deterministic local runtime: native preview without mutation, approve/apply, deny, changed files, queued follow-up, disconnect and Stop during review.

For a UI-only browser preview, build then run node scripts/preview.mjs and open http://127.0.0.1:8137. This uses mock connection state and cannot execute tools. The Playwright function in scripts/check-ui.js exercises review, queueing, copying, Markdown, draft preservation and 320/410px panel layouts. FEATURES.md contains the official Codex/Claude reference links and remaining feature inventory. scripts/check-history-ui.js covers history search, resume, rename, deletion, per-chat drafts and new-chat retention. Native host checks also reopen persisted chats after reload, continue with the original session ID and block pending replay. scripts/check-inputs-ui.js checks team labeling, access controls, attachment chips, dictated draft text and narrow layouts with mock inputs; it does not exercise a physical microphone or a live SAP system.

Backend protocol tests from the repository root:

.venv/Scripts/python.exe -m pytest backend/tests/test_editor_runtime.py backend/tests/test_runtime_api_access.py

For F5 debugging in this folder, create a local extensionHost launch configuration with --extensionDevelopmentPath=${workspaceFolder} after building. Run the backend separately with your usual local configuration.

SAP ADT and SAP Systems integration (0.29.0)

Open Flockion: SAP Development Tools, or the server icon in the chat header. The panel opens SAP's Connection Manager and ADT destination setup, then connects to ADT's local MCP server. The installed SAP extensions manage credentials. Flockion discovers the live tool schemas and lets your current agent or team use them through the editor bridge. SAP calls and source edits wait for your review, including in Full access. In Ask and Plan, the agent may request SAP reads (search, source, transport lookups) through the same review. Allow for session on a SAP review skips later reviews for that tool until SAP disconnects or VS Code reloads; the SAP panel lists these tools and can revoke them.

SAP virtual workspace folders support source inspection, line references and reviewed edits with file-version checks. Checkpoint restore covers source only; activation and transports are separate SAP operations. This needs a real SAP development destination and a backend restart to load the updated editor protocol. See the bundled SAP_SETUP.md for complete setup and limitations.

Optional community SAP tools (0.30.0)

The SAP panel can start a separately installed Vibing Steampunk executable using a saved system alias. Official ADT remains the default; credentials stay in the selected provider. Read-only mode is requested by default, and every SAP call still requires review unless you allowed that tool for the session. Compact discovery retrieves one tool schema at a time. Structured SAP errors are recorded as failures and pause the queue. See the bundled SAP_SETUP.md and SAP_INTEGRATION_REVIEW.md for setup, the review of both repositories and the remaining SAP work.

SAP evidence and transports (0.31.0)

Open the SAP panel's Verification and transports section to inspect recorded Unit/ATC counts, result IDs, source hashes and returned transport/import details. Prepare reviewed check/status drafts there, copy normalized evidence, or include a summary in the existing transcript export and Jira draft flows.

Source hashes describe observed workspace files, with stale bindings marked after edits and rechecking required after reopening. They do not prove the active SAP revision tested or a successful transport import. Unknown response formats remain unverified. See SAP_SETUP.md for limits and supported evidence.

Before/after SAP checks (0.32.0)

Choose Use as baseline on a recognized Unit/ATC record before changing code. Later compatible records display count changes. Comparisons require the same recorded connection, workspace and requested scope, and are refused after a reconnect or invalidated later source binding. Counts do not prove which findings are new. See SAP_SETUP.md for the full workflow and limits.