SCCE

License: PROPRIETARY. SCCE is source-visible proprietary software owned by Walsh Technical Group. All rights reserved.

SCCE is a local-first cognitive runtime and developer platform for building, operating, and auditing grounded assistant behavior over private corpora, codebases, tools, memories, and bounded automation loops. The repository is a TypeScript monorepo with server, web, CLI, desktop, VS Code, core cognition, database, security, compute, plugin, and type packages.

This README is the 3,000-foot operating overview: close enough to show the real moving parts, without replacing the generated API and code references. For exhaustive generated reference material, start with docs/reference-index.md.

What Is In This Repository

SCCE is organized as a monorepo:

• apps/server: Fastify API server, route registration, auth/tier gates, ingestion, vault, brain, conversation, code-agent, system, media, voice, and operator surfaces.
• apps/web: browser UI for chat, corpus/vault, brain import/export, settings, training, system, evidence, and operator workflows.
• apps/cli: terminal client for chat, ingest, vault inspection, and local operation.
• apps/vscode: VS Code extension with a sidebar control surface for server lifecycle, modes, corpus ingest, brain operations, Ollama wiring, tasks, validation, logs, voice, and multimodal tools.
• apps/desktop and apps/trainer-desktop: Electron shells around the local runtime and training surfaces.
• packages/core: cognitive runtime, retrieval, reasoning, memory, self-evaluation, code-agent logic, local model adapters, media/voice helpers, skill systems, world/belief/task systems, and proof harness components.
• packages/db: database access, migrations, and persistence helpers (Postgres-only; SQLite is not supported).
• packages/compute: parallel ingestion, worker pipelines, and corpus-processing compute paths.
• packages/security: permission, redaction, trust, and safety support code.
• packages/plugins: plugin scaffolding and generated app/tool templates.
• packages/types: shared type contracts.
• scripts: operational commands, proofs, ingest jobs, audits, demos, bundle tools, calibration, and generated documentation tooling.

Runtime Shape

At runtime, SCCE is centered on the local server. The server exposes a broad API surface through deployment profiles:

• Minimal profile: health, chat, conversation, assistant, LLM-layer primitives, and consumer chat.
• Operator profile: vault/corpus ingest, training, visualization, system, artifacts, evidence, brain bundles, reasoning, code generation, gaps, policy, skills, goals, trust, consolidation, and other operator surfaces.
• Code-operator profile: autonomous coding surfaces, code-agent planning, patching, validation, repair, workspace operations, and learning.
• Full profile: high-privilege and experimental surfaces such as voice, connectors, system config, images, AGI proof surfaces, and consciousness/self-model surfaces.

The server defaults used by the VS Code extension are local and bounded:

• Note: SCCE only supports Postgres. Do not use SCCE_DB_BACKEND=sqlite. Set SCCE_DB_URL for Postgres.

• SCCE_DEPLOYMENT_PROFILE=full
• SCCE_DEV_MODE=1
• SCCE_DEV_AUTH_TIER=T4_cleared
• SCCE_HOST=127.0.0.1
• SCCE_PORT=3000

The exact route list is generated from Fastify registrations in docs/api-reference.md.

Core Operating Loops

SCCE's main loops are implemented in code, not as documentation-only architecture:

• Corpus ingestion: files are read through guarded vault paths, eventized, chunked, correlated, trained into models, and attached to vault or conversations.
• Grounded conversation: user input routes through conversation state, memory/retrieval, evidence handling, answer generation, abstention/refusal, and optional post-processing.
• Brain portability: learned model state can be exported, inspected, diffed, imported, and hydrated through .brain bundles.
• Cognitive settings: temporal decay, consolidation, evidence gravity, active policy, and friction thresholds are exposed through persisted cognitive settings routes.
• Code-agent loop: repository scanning, task creation, seam detection, planning, approval gates, patch records, validation, repair gradients, ledger entries, learnings, and skill retrieval.
• Local proof loop: pnpm agi:proof runs the deterministic closed-loop proof harness.
• External model overlay: SCCE can opt in to an OpenAI-compatible LLM endpoint, including Ollama, while keeping the native grounded pipeline and air-gap policy explicit.

Local Development

Fast path from a fresh checkout:

pnpm quickstart

Print the no-magic version without running install/build:

pnpm quickstart -- --print

Install dependencies:

pnpm install

Start the server:

pnpm dev:server

Start the web UI:

pnpm dev:web

Run both consumer surfaces:

pnpm start:consumer

pnpm dev starts the server and web UI with Windows-safe environment defaults. Postgres is mandatory: set SCCE_DB_URL before starting the server.

By default the memory-budgeted dev/start scripts enable the local Ollama overlay:

SCCE_ALLOW_EXTERNAL_LLM=1
SCCE_LLM_BASE_URL=http://192.168.1.24:11434/v1
SCCE_LLM_MODEL=qwen3-coder:30b
SCCE_LLM_API_KEY=ollama

Run the VS Code extension build:

pnpm --filter scce-vscode run build

Package the VS Code extension:

pnpm --filter scce-vscode run package

Run the deterministic local closed-loop proof:

pnpm agi:proof

Important Commands

Common validation and quality commands:

pnpm build
pnpm test
pnpm lint
pnpm quality:check
pnpm quality:deep
pnpm audit:hostile
pnpm audit:tests
pnpm verify:offline
pnpm verify:no-telemetry
pnpm verify:sandbox

Corpus and brain commands:

pnpm ingest:folder
pnpm ingest:wiki
pnpm wipe:corpus
pnpm brain:export
pnpm brain:import
pnpm brain:diff
pnpm brain:keygen
pnpm brain:federate

Proof and benchmark commands:

pnpm proof:run
pnpm proof:run:fast
pnpm proof:all
pnpm bench
pnpm bench:strict
pnpm eval:strict
pnpm publishable:check

The full generated script catalog is in docs/script-reference.md.

Corpus, Vault, And Brain State

SCCE treats corpus and brain data as local operational state:

• data/: default data directory for local models, corpora, shards, CAS, learned memory, temporary ingest output, and generated artifacts.
• SCCE_DATA_DIR: overrides the runtime data directory.
• SCCE_VAULT_ALLOWED_ROOTS: comma-separated allowlist for guarded ingest/code paths.
• /api/ingest: ingests a guarded file tree into the vault/corpus pipeline.
• /api/brain/manifest: reports live concept, relation, primitive, and mouth statistics.
• /api/brain/export: exports a .brain bundle.
• /api/brain/inspect: reads an uploaded .brain manifest without writing state.
• /api/brain/diff: compares an uploaded .brain with current local state.
• /api/brain/import: verifies and hydrates a .brain bundle, with production trust-key safeguards.

The VS Code extension exposes these directly in its SCCE sidebar under the knowledge controls.

Ollama And External LLM Overlay

SCCE is local/offline by default. External LLM use is opt-in.

To allow the optional OpenAI-compatible LLM overlay:

SCCE_ALLOW_EXTERNAL_LLM=1
SCCE_LLM_BASE_URL=http://127.0.0.1:11434/v1
SCCE_LLM_API_KEY=ollama
SCCE_LLM_MODEL=qwen2.5-coder:7b

For Ollama, start the local model server separately:

ollama serve
ollama pull qwen2.5-coder:7b

The VS Code extension can configure and probe this path. When disabled, it starts the server with external LLM posture off. When enabled, SCCE still routes through its grounding and filtering machinery before returning assistant output.

VS Code Extension

The VS Code extension is in apps/vscode and contributes an SCCE activity-bar container. It can:

• start, stop, and restart the local SCCE server;
• switch assistant mode, voice mode, and capability level;
• send grounded conversation turns;
• attach files and folders for tool-aware chat;
• use selected editor text as context;
• run voice input and speech output in the webview where available;
• scan the repository and create/resume code tasks;
• run validation commands and inspect ledgers;
• run pnpm agi:proof;
• ingest configured corpus paths;
• show brain manifest, export .brain, inspect .brain, and import .brain;
• load, edit, save, and reset cognitive settings;
• configure/probe Ollama as an external OpenAI-compatible LLM endpoint;
• show extension and server logs written to VS Code global storage.

Build and package:

pnpm --filter scce-vscode run package

Install a packaged VSIX locally:

code --install-extension apps/vscode/scce-vscode-0.1.0.vsix --force

API And Code References

The exhaustive references are generated from code:

• docs/reference-index.md: generated documentation index and coverage counts.
• docs/package-reference.md: every package manifest and package-level metadata.
• docs/script-reference.md: every package.json script across the monorepo.
• docs/api-reference.md: every Fastify route registration under apps/server/src.
• docs/code-reference.md: every named class, constructor, method, function, function variable, interface, type alias, and enum found in source.

Regenerate references after code changes:

pnpm docs:generate

Safety And Governance Posture

SCCE is designed around explicit local operation and auditable control paths:

• external LLM access is disabled unless SCCE_ALLOW_EXTERNAL_LLM=1;
• corpus and code paths are guarded by allowlists;
• high-capability actions are tiered and permissioned;
• brain import can require trust keys in production-like environments;
• code-agent operations route through approval gates, patch records, validation, ledger entries, and bounded workspace operations;
• offline verification is available through pnpm verify:offline and pnpm verify:no-telemetry;
• proprietary headers can be checked and repaired with pnpm headers:check and pnpm headers:fix.

License

SCCE is source-visible proprietary software. The repository license is PROPRIETARY. All rights are reserved by Walsh Technical Group. Possession of source code does not grant redistribution, sublicensing, hosted-service, model-training, or commercial deployment rights unless separately licensed in writing.