PACE AI Wrapper

Current Marketplace version: 0.1.9

PACE AI Wrapper is a VS Code extension for running a guided PACE agent chain and recording the work in a way that can be reviewed later. It creates request/session files in your workspace, captures local telemetry, and can send signed telemetry batches to AI CostGuard when your organization enables remote telemetry.

It is useful when teams need a clear record of how AI-assisted work moved from requirements to test planning and implementation, especially in environments where enterprise code assistant usage reports are limited or delayed.

This extension is not affiliated with, endorsed by, or sponsored by GitHub or Microsoft.

What's new in 0.1.9

Re-register CostGuard workstation when configured user identity changes.

What the wrapper does

The wrapper runs a request through a predictable agent flow:

REQ-01 -> TDD-01 -> DEV-01 -> DEV-02 -> DONE

DEV-02 can loop when another build/fix iteration is needed. Each agent writes a structured completion manifest:

product-specs/{request-id}/.pace/agent-completion.json

The wrapper reads that manifest and decides the next step. This keeps the chain explainable: users can inspect the generated files and see why the next agent ran.

Example dynamic chain:

REQ-01 -> TDD-01 -> DEV-01 -> DEV-02 -> DEV-02 -> DEV-02 -> DONE

If the chain cannot finish within its guardrails, it stops for HUMAN_REVIEW.

Quick start

Install PACE AI Wrapper from the Visual Studio Marketplace.
When VS Code asks whether to configure AI CostGuard, choose Configure CostGuard if your organization provided a tenant and registration token. Choose Use local only if you only want workspace-local telemetry.
Open the repository where you want to run the workflow.
Open the Command Palette:
- Windows/Linux: Ctrl + Shift + P
- macOS: Cmd + Shift + P
Run PACE Wrapper: Run Dynamic Agent Chain.
Review the generated files under .pace/ and product-specs/.

Remote user one-command setup

Administrators can give developers a single terminal command that installs the Marketplace extension and writes the required CostGuard settings. The developer does not need to clone this repository.

macOS or Linux:

bash -c 'set -euo pipefail
code --install-extension ust-pace-ai.copilot-wrapper --force
bootstrap="$(ls -td "$HOME"/.vscode/extensions/ust-pace-ai.copilot-wrapper-*/scripts/bootstrap-vscode.js | head -1)"
COSTGUARD_REGISTRATION_TOKEN="<registration-token>" node "$bootstrap" \
  --tenant-id ust-pace \
  --ingestion-base-url https://dev.ustpace.com/costguard-ingestion \
  --user-email user@customer.com \
  --github-username github-login \
  --display-name "User display name" \
  --source-surface vscode-code-assistant'

Windows PowerShell:

$env:COSTGUARD_REGISTRATION_TOKEN = '<registration-token>'
code --install-extension ust-pace-ai.copilot-wrapper --force
$extension = Get-ChildItem "$env:USERPROFILE\.vscode\extensions" -Directory -Filter "ust-pace-ai.copilot-wrapper-*" |
  Sort-Object LastWriteTime -Descending |
  Select-Object -First 1
node "$($extension.FullName)\scripts\bootstrap-vscode.js" `
  --tenant-id ust-pace `
  --ingestion-base-url https://dev.ustpace.com/costguard-ingestion `
  --user-email user@customer.com `
  --github-username github-login `
  --display-name "User display name" `
  --source-surface vscode-code-assistant

Local development checkout:

printf '%s' '<registration-token>' | npm run setup:vscode -- \
  --install \
  --registration-token-stdin \
  --tenant-id ust-pace \
  --ingestion-base-url https://dev.ustpace.com/costguard-ingestion \
  --user-email user@customer.com \
  --github-username github-login \
  --display-name "User display name" \
  --source-surface vscode-code-assistant

The command installs the Marketplace extension, runs the bootstrap script shipped inside that extension, merges the required paceWrapper.* keys into VS Code user settings.json, and leaves existing settings untouched. When VS Code starts or reloads with complete CostGuard settings, the extension registers the workstation automatically.

Use --settings-file when bootstrapping a non-default VS Code profile, VS Code Insiders, Cursor, or another compatible editor profile.

Prerequisites on the workstation:

VS Code command line tool available as code
Node.js available as node
Network access to the Visual Studio Marketplace

Updates

VS Code updates Marketplace extensions automatically when extension auto-update is enabled. If a user has disabled auto-update, PACE AI Wrapper checks the Visual Studio Marketplace once per day and shows a small notification when a newer version is available.

The update notice opens the extension page in VS Code so the user can install the current Marketplace version. It does not force an update or change workspace files.

Agents included

Agent	Purpose	Output	Next
REQ-01	Requirements shaping	`req01_spec.md`	TDD-01
TDD-01	Test design	`tdd01_test_plan.md`	DEV-01
DEV-01	Build planning	`dev01_build_plan.md`	DEV-02
DEV-02	Build/fix iteration	`dev02_iteration_{n}.md`	DEV-02, DONE, or HUMAN_REVIEW

Files created in your repository

When you run the wrapper, it creates:

.pace/
  current-session.json
  sessions/{request-id}.json
  telemetry/events.ndjson

product-specs/
  index.md
  {request-id}/
    req01_spec.md
    tdd01_test_plan.md
    dev01_build_plan.md
    dev02_iteration_1.md
    dev02_iteration_2.md
    dev02_iteration_3.md
    .pace/agent-completion.json

Main commands

Search for PACE Wrapper in the Command Palette.

Command	What it does
`PACE Wrapper: Start REQ-01`	Starts a new request chain
`PACE Wrapper: Start Next Agent`	Reads the current completion manifest/session and runs the next agent
`PACE Wrapper: Run Dynamic Agent Chain`	Runs REQ-01 → TDD-01 → DEV-01 → DEV-02 loop automatically
`PACE Wrapper: Open Current Session`	Opens `.pace/current-session.json`
`PACE Wrapper: Open Telemetry Log`	Opens `.pace/telemetry/events.ndjson`
`PACE Wrapper: Configure CostGuard`	Guides first-time setup for CostGuard URL, tenant, user identity, token, and telemetry mode
`PACE Wrapper: Register CostGuard Installation`	Generates a local Ed25519 key pair and registers this workstation with CostGuard
`PACE Wrapper: Sync Telemetry to CostGuard`	Sends pending telemetry from the SDK SQLite outbox as a signed batch

CostGuard remote telemetry setup

The wrapper uses local-only telemetry by default. In that mode, nothing is sent to CostGuard.

On first activation, the extension offers a guided setup. Users can also run PACE Wrapper: Configure CostGuard from the Command Palette at any time.

The setup guide asks for:

telemetry mode
CostGuard ingestion base URL
tenant ID
registration token
optional email, user ID, and GitHub username
source surface

The registration token entered through the setup guide is stored in VS Code SecretStorage, not in settings.json. Administrators can still manage settings centrally through MDM or a managed settings.json.

Recommended settings:

{
  "paceWrapper.telemetryMode": "both",
  "paceWrapper.costGuard.ingestionBaseUrl": "https://dev.ustpace.com/costguard-ingestion",
  "paceWrapper.costGuard.tenantId": "tenant-postman-dev",
  "paceWrapper.costGuard.registrationToken": "<short-lived customer registration token>",
  "paceWrapper.costGuard.userEmail": "user@customer.com",
  "paceWrapper.costGuard.githubUsername": "github-login-if-known",
  "paceWrapper.costGuard.sourceSurface": "vscode-code-assistant",
  "paceWrapper.costGuard.autoSync": true
}

Installation flow:

Admin generates one short-lived customer registration token for the tenant.
The token is distributed through LastPass, MDM, or the customer software portal.
Each developer installs the wrapper once.
The wrapper runs PACE Wrapper: Register CostGuard Installation.
A unique workstation installation_id and Ed25519 key pair are created.
The private key stays in VS Code SecretStorage on the workstation.
Each telemetry batch is signed with the private key and sent with:
- X-Installation-Id
- X-Key-Id
- X-Timestamp
- X-Content-SHA256
- X-Signature

The shared registration token is not user identity. User correlation comes from the unique installation plus hashed email or SCM identity captured during registration.

Data collected

The wrapper is designed to send operational metadata, not source content. When remote telemetry is enabled, CostGuard receives fields such as:

Category	Examples
Installation	tenant ID, installation ID, key ID, source surface, extension version
User correlation	hashed email or configured user ID, optional GitHub username
Workspace context	SCM provider, repo host, organization, repository name, branch, commit SHA
Privacy-preserving hashes	repository URL hash, remote URL hash, workspace path hash, device hash
Agent activity	event ID, request ID, execution ID, agent ID, stage, iteration, status, timestamps
Output references	generated file paths, completion manifest path, next-agent decision, next-agent reason
Usage estimate	estimated token count based on generated text length

The wrapper does not send these by default:

source code
prompts
full diffs
terminal output
raw model responses
plaintext email addresses
registration tokens
private signing keys

Local mode writes the human-readable event log only inside your workspace at .pace/telemetry/events.ndjson.

The tenant ID is the customer boundary. GitHub organizations and repositories are captured as source context from the active workspace remote; users do not choose an org/project ID during setup.

Basic security model

Remote telemetry is off by default. Users or administrators must choose both or remote.
Workstations register with CostGuard before sending remote telemetry.
Each registered workstation gets a unique installation ID and Ed25519 signing key.
The private signing key is stored in VS Code SecretStorage, not in the workspace .pace folder.
Telemetry batches are signed. The ingestion service verifies the installation ID, key ID, timestamp, body hash, and signature.
Registration tokens are used only to register a workstation. They are not used as user identity and are not sent with every event.
A copied repository does not copy the private signing key. A different workstation must register as a new installation before it can send telemetry.
The SDK keeps only pending or failed remote events in its SQLite outbox and deletes acknowledged events after ingestion accepts them.

SCM and identity model

Telemetry is SCM-agnostic. The wrapper detects GitHub, GitLab, Bitbucket, Azure DevOps, self-hosted Git, or local folders without a remote.

For each event, the wrapper sends metadata only:

{
  "scm": {
    "provider": "github",
    "host": "github.com",
    "organization": "UST-PACE",
    "repository": "AI-costguard-ingestion",
    "repo_url_hash": "sha256:...",
    "remote_url_hash": "sha256:...",
    "branch": "main",
    "commit_sha": "...",
    "workspace_path_hash": "sha256:...",
    "context_confidence": "high"
  }
}

When the user works outside a Git repo, the event is still valid and uses:

{
  "scm": {
    "provider": "none",
    "workspace_path_hash": "sha256:...",
    "context_confidence": "none"
  }
}

The idempotency key is the server-side event identity:

tenant_id + installation_id + event_id

Repo identity is for analytics and correlation only:

scm_provider + scm_host + repo_url_hash

Local telemetry files

Remote-enabled installs still keep local troubleshooting files:

.pace/telemetry/events.ndjson          # workspace-local append-only human-readable event log
~/.config/pace/outbox.db               # SDK SQLite outbox for pending/failed remote telemetry
~/.config/pace/logs/costguard-sdk.log  # bounded SDK operational log

On Windows, the SDK uses %APPDATA%\PACE instead of ~/.config/pace.

The SDK deletes acknowledged outbox events after the ingestion API accepts them, keeps failed events for a short retention window, and rotates logs so local files do not grow without bounds.

No prompts, source code, terminal output, full diffs, or plaintext email addresses are sent by default.

Handling copied workspaces

The workspace .pace folder is not the wrapper identity. It only contains local session and telemetry state.

Identity is stored outside the workspace:

the private Ed25519 key is stored in VS Code user-level SecretStorage
the installation metadata is stored in VS Code extension global storage
the server registration includes a machine/device hash

This does not require local admin rights. VS Code SecretStorage is user-scoped and uses the current user's OS credential/keychain backend where available.

If a developer copies a repository, including .pace, to another laptop:

The copied laptop will not have the original private signing key in its VS Code SecretStorage.
The wrapper will register a new installation_id before it can send telemetry.
If VS Code profile/global storage is also copied, the machine hash check forces re-registration on the new laptop.
Copied pending telemetry can only be sent under the new installation, and server-side event dedupe prevents double counting for repeated event_id values.

Policy rule:

.pace is workspace/session state.
VS Code SecretStorage + global storage is user/device identity.

Recommended workflow

Option A: step-by-step

Run:

PACE Wrapper: Start REQ-01

Enter product and task.
When complete, run:

PACE Wrapper: Start Next Agent

Repeat until the next agent is DONE.

Option B: full chain

Run:

PACE Wrapper: Run Dynamic Agent Chain

This automatically runs:

REQ-01 → TDD-01 → DEV-01 → DEV-02 → DEV-02 → DEV-02 → DONE

DEV-02 may run more than once when there is more implementation work to close.

Optional code assistant entry point

The extension also contributes a simple @pace chat participant, if your VS Code build supports the Chat Participant API.

Example:

@pace /req01 product=demo-product task="Add signed CostGuard telemetry"

Then:

@pace /next

Or run the whole chain:

@pace /chain product=demo-product task="Add signed CostGuard telemetry"

Completion manifest example

Each agent writes:

{
  "schema_version": "pace.agent-completion.v0.2",
  "request_id": "demo-product-build-a-dynamic-001",
  "execution_id": "uuid",
  "agent_id": "dev02",
  "agent_version": "0.2.0",
  "status": "completed",
  "iteration": 2,
  "outputs": [
    "product-specs/demo-product-build-a-dynamic-001/dev02_iteration_2.md"
  ],
  "outcome": {
    "tests_passed": false,
    "open_work_items": 1
  },
  "next": {
    "agent_id": "dev02",
    "reason": "1 simulated work item remains; continue DEV-02 iteration.",
    "input_files": [
      "product-specs/demo-product-build-a-dynamic-001/dev01_build_plan.md"
    ]
  },
  "generated_at": "2026-06-11T10:00:00.000Z"
}

The wrapper validates next.agent_id before running the next step.

Telemetry events

Telemetry is appended to:

.pace/telemetry/events.ndjson

Example event types:

agent.chain.started
agent.execution.started
agent.tool_call.completed
agent.completion_manifest.written
agent.execution.completed
agent.chain.completed

Each event includes useful fields such as:

request_id
execution_id
agent_id
stage
iteration
user
github remote / branch / commit
output_file
completion_manifest
estimated_tokens
next_agent
next_reason

Token usage is estimated using generated text length divided by 4. Treat this as a directional usage estimate, not an exact billing value.

Why this pattern matters

For real PACE agents, the recommended contract is:

Agent writes durable output files
Agent writes .pace/agent-completion.json
Wrapper validates next-agent decision
Wrapper records telemetry
Wrapper starts/prepares the next agent

This avoids relying on a single long code assistant session and reduces role bleed/context overload.

Current limits

The wrapper does not depend on enterprise AI assistant usage metrics. It uses:

local workspace context
Git remote/branch/commit metadata
local telemetry files
completion manifests

Exact model token and cost data requires a model provider or governed backend that returns those values. The wrapper records a local estimate when exact usage is not available.

Release process

Use the release preparation script so Marketplace documentation, package metadata, changelog, commit, and tag stay in sync.

Prepare a local release for review:

npm run release:prepare -- 0.1.4 --note "Updated Marketplace documentation."

Prepare, commit, tag, and push a release:

npm run release:prepare -- 0.1.4 --note "Updated Marketplace documentation." --push

The script updates:

package.json
package-lock.json
README.md
CHANGELOG.md

It also runs tests, validates the extension structure, packages a VSIX, checks the release metadata, and verifies the version is not already published in the Visual Studio Marketplace.

CHANGELOG.md is kept to the latest five release entries by the release preparation script.

PACE AI Wrapper

UST PACE AI

PACE AI Wrapper

What's new in 0.1.9

What the wrapper does

Quick start

Remote user one-command setup

Updates

Agents included

Files created in your repository

Main commands

CostGuard remote telemetry setup

Data collected

Basic security model

SCM and identity model

Local telemetry files

Handling copied workspaces

Recommended workflow

Option A: step-by-step

Option B: full chain

Optional code assistant entry point

Completion manifest example

Telemetry events

Why this pattern matters

Current limits

Release process