Workspaces and code intelligence

© 2026 Quadropic Pvt Ltd. Proprietary and confidential. Use restrictions.

Workspace boundaries#

A workspace is the project directory that anchors:

• task history;
• file, search, and shell tools;
• integrated terminal sessions;
• Code Atlas indexing;
• Git commands;
• Virtual Edit creation;
• auto-archive rules.

Choose the narrowest directory that still contains the build and test context the task needs. Selecting a monorepo root is appropriate for cross-package changes; selecting a package is better for isolated work if its commands run independently.

Add, select, pin, and filter#

• Add a workspace from the sidebar or with ⌘O / Ctrl+O.
• Choose the active workspace below the composer before creating a task.
• Pin long-lived workspaces so they remain prominent.
• Use the sidebar filter to limit visible directories and activity range.
• Right-click a workspace to start a thread, explore it, open settings, pin, archive, or delete it.

Archiving removes a workspace from the active navigation without deleting the source directory. Treat any explicit delete confirmation carefully and read the dialog’s target before accepting.

Code Atlas: when and how to use it#

Code Atlas is a local semantic index of the selected codebase. It helps the harness find relevant symbols and connected execution paths when exact filenames or text are not known.

Index when#

• the repository has many packages or layers;
• a feature crosses UI, service, storage, and API boundaries;
• you need to understand callers and callees;
• you are planning a refactor;
• the agent repeatedly searches broad terms without finding the implementation.

Skip or defer when#

• the task is confined to a known file;
• the repository is tiny;
• the source tree is mostly generated;
• you need a quick exact-string change;
• indexing time exceeds the likely investigation time.

Index lifecycle#

Open Settings → Workspace → Code Intelligence.

1. Select the workspace at the top.
2. Keep Use Code Atlas here enabled.
3. Choose Index codebase.
4. Wait for the progress indicator and Index ready status.
5. Use Open Code Atlas for a visual view.

Choose Sync index after:

• checking out another branch with substantial differences;
• pulling or merging large changes;
• moving or renaming modules;
• completing a broad refactor;
• noticing Code Atlas results that describe old code.

Turning Code Atlas off preserves the index. Clear index deletes only a Syntheo-created index, never source files.

Ask Code Atlas-friendly questions#

Use concrete domain nouns:

Trace checkout submission from the UI event through validation and the payment
adapter. Identify ownership boundaries and failure cleanup.

Find the account-session lifecycle: sign-in, persistence, refresh, expiration,
and sign-out. Identify every caller that can observe stale state.

Avoid vague requests such as “How does everything work?” Split them into a feature and a flow.

Exact context with @#

Code Atlas is for discovery; @ mentions are for explicit scope.

Good combinations:

Use Code Atlas to trace callers of @src/features/cart/state.ts, then explain
which call sites can receive stale cart data.

Change only @src/components/Banner.tsx and its nearest test. If another file is
required, explain why before editing it.

Mention a directory when every file inside it is in scope. Mention individual files when the task must stay narrow.

Integrated work panels#

Terminal#

Open with `Ctrl+`` on all supported platforms.

Use it to:

• reproduce a failure;
• run tests, type checks, linters, or builds;
• inspect Git state;
• execute a command the agent recommends;
• keep a task-scoped shell alive while you inspect the chat.

The Terminal panel starts in the effective task directory: the workspace, thread Virtual Edit, or inherited room worktree. Its shell selector remembers your preferred detected shell. Refresh restarts the session; unsaved terminal state and running foreground processes may be lost.

Browser#

Open with ⌘⇧B / Ctrl+Shift+B.

Use it for:

• reproducing a web UI issue;
• keeping a logged-in development session visible;
• checking a local server;
• selecting page elements and bringing their details into the composer;
• reviewing a page while a Browser sub-agent works.

The browser is task-scoped and persistent while its thread process remains alive. A page can still require human handling for credentials, CAPTCHA, MFA, payments, or legal acceptance.

The Browser preset and Browser panel are complementary:

• the preset selects web-aware model behavior;
• the panel gives you and browser automation a page surface.

File Diff#

Open with ⌘⇧D / Ctrl+Shift+D.

The panel aggregates line-level changes captured from edit operations. Use it to:

• review files without leaving Syntheo;
• jump from an edit tool card to the relevant diff;
• compare addition/deletion totals;
• copy selected diff text into a follow-up.

The panel is evidence, not a replacement for git diff. Tool-captured changes may not represent external edits, generated files, or every Git state transition. Use the terminal for the authoritative repository diff.

Open in an external app#

The top-bar Open control launches the effective directory in a detected editor or file app. Use the adjacent menu to choose the preferred target; ⌘P / Ctrl+P opens in that preferred app.

For a Virtual Edit or room worktree, the effective directory may be the isolated worktree rather than the base workspace. Check the directory label before editing externally.

Thread housekeeping#

Open Settings → Workspace → Thread housekeeping.

Auto archive can use:

• inactivity age;
• maximum active-thread count;
• either rule together, archiving the oldest eligible threads first.

Archived threads remain in storage. Pin work you need to keep active, then set housekeeping aggressively enough that the sidebar reflects current work rather than history.

Suggested starting policies:

Use task titles that remain meaningful after the prompt is no longer visible. Pin incident investigations, migration threads, or long-running coordination tasks.

Context hygiene across a project#

Put information in the narrowest durable place:

Do not keep canonical requirements only in a very long chat. Move stable decisions into the repository, a plan, or a room artifact, then mention that source in follow-up tasks.