Sharing Context Packs Across Projects and Teams

Introduction

In high-velocity engineering organizations, the most significant risk is not the loss of code, but the loss of context. Decisions made in isolation often fail to permeate the rest of the organization, leading to repetitive mistakes, architectural drift, and a fragmented understanding of technical debt. Hopsule addresses this through Context Packs—also known as Capsules—which serve as the primary vehicle for portable organizational judgment.

This guide provides an exhaustive walkthrough on how to curate, share, and enforce Context Packs across multiple projects and teams. By mastering the distribution of these bundles, you ensure that your team's most critical decisions and memories are not merely archived, but are actively remembered and enforced across every developer's IDE, terminal, and AI assistant session. Whether you are scaling a single team or managing a global engineering department, understanding how to mobilize context is essential for maintaining governance and preservation of institutional knowledge.

Prerequisites

Before you begin sharing Context Packs across your organization, ensure you have met the following requirements within the Hopsule environment:

• Verified Account: You must have an active Hopsule account with administrative or project-lead permissions for the source project.

• Accepted Decisions: A Context Pack is only as strong as the decisions it contains. Ensure you have at least one Decision in the Accepted state. Decisions in Draft or Pending states can be included but will not trigger enforcement warnings in the Hopsule IDE Extension.

• Established Memories: To provide the necessary "why" behind your decisions, ensure you have associated append-only Memories with your decisions to provide traceability.

• Hopsule Dashboard Access: Most sharing and configuration actions are performed through the web-based Hopsule Dashboard.

Creating and Configuring Your Context Pack

A Context Pack is a curated bundle of Decisions and Memories designed to be portable. It acts as a snapshot of organizational judgment that can be dropped into any project to provide immediate context-awareness.

1. Log in to the Hopsule Dashboard and navigate to the project containing the context you wish to share.

2. Locate the Context Packs (or Capsules) tab in the primary navigation sidebar.

3. Click the Create Capsule button in the top-right corner of the interface.

4. Provide a descriptive name. Effective naming conventions often follow a "Domain/Standard" format, such as "Security/Authentication-Standards" or "Infrastructure/Cloud-Native-Patterns."

5. In the Selection Matrix, browse through your project's Decisions and Memories. Check the boxes next to the specific entries you wish to include in this bundle. Remember that Memories are append-only and provide the historical reasoning that justifies the Decisions.

6. Set the initial Lifecycle State. For a new pack intended for immediate use, select Active. If you are still curating the content, keep it in Draft.

7. Click Save Capsule. Your context is now bundled and ready for distribution.

Sharing Context Within the Hopsule Dashboard

The Hopsule Dashboard provides two primary methods for sharing: internal organizational sharing and external sharing via secure tokens.

Internal Organizational Sharing

This method is ideal for sharing context between different teams (e.g., from the Platform Team to the Frontend Team) within the same Hopsule Organization.

1. Within the Hopsule Dashboard, select the Capsule you wish to share.

2. Navigate to the Permissions & Visibility settings.

3. Toggle the visibility to Organization-Wide. This makes the Capsule discoverable by any project lead within your organization.

4. Other project leads can now go to their own project's Context Packs tab, click Import Capsule, and select your shared pack from the internal directory.

External Sharing via Secure Tokens

For sharing context with external partners, contractors, or across entirely separate Hopsule Organizations, use Secure Tokens. This ensures that enforcement and remembrance remain intact even outside your primary organizational boundaries.

1. Open the specific Capsule in the Hopsule Dashboard.

2. Click on the Sharing & API sub-menu.

3. Select Generate Secure Token. You will be prompted to set an optional expiration date and a scope (Read-only is the default and recommended setting for Context Packs).

4. Copy the generated token. Warning: For security reasons, this token is only displayed once. It is protected by AES-256 encryption at rest and TLS 1.3 in transit.

5. Provide this token to the recipient. They can use the Hopsule CLI or the Hopsule Dashboard to link this Capsule to their local projects by selecting Link via Token.

Leveraging the Knowledge Graph for Context Visualization

When sharing multiple Context Packs, it can become difficult to visualize how different decisions interact. The Knowledge Graph (also referred to as the Brain) in the Hopsule Dashboard provides a real-time visualization of these relationships.

• Open the Brain view from the Dashboard sidebar.

• Filter the view by Capsule to see how shared decisions from different packs intersect.

• Identify potential contradictions or redundancies between imported Context Packs and local project decisions.

• Use Hopper, the built-in AI assistant, to analyze the graph. You can ask Hopper, "Are there any conflicting enforcement rules between the Security Capsule and our local project decisions?"

Consuming Shared Context in Development Workflows

Once a Context Pack is shared and linked to a project, it becomes active across all Hopsule product surfaces. This is where the philosophy of "enforcement is remembrance" manifests.

Enforcement in Hopsule for VS Code

The Hopsule for VS Code extension (and its compatibility with Cursor) is the primary surface for decision enforcement. When a developer works on a project that has an imported Context Pack:

• The extension automatically downloads the linked Capsules (processing is done locally to ensure no source code leaves the environment).

• If a developer writes code that contradicts an Accepted Decision within an active Context Pack, Hopsule for VS Code will surface an inline warning.

• The sidebar tree view allows developers to browse all active Decisions from imported Context Packs, providing immediate access to the "Why" (the linked Memories) without leaving the IDE.

• If a contradiction is intentional, the developer can Override the warning, which requires an acknowledgment that is logged in the Hopsule Dashboard for audit purposes.

Context-Awareness via Hopsule MCP

For teams using AI agents (like Claude or specialized coding assistants), the Hopsule MCP (Model Context Protocol) server is the bridge. By connecting your AI agent to the Hopsule MCP:

• The AI agent gains read-only access to all active Context Packs linked to the project.

• The agent becomes "context-aware" automatically, meaning it will suggest code that aligns with your organization's preserved decisions.

• The AI agent cannot mutate or delete decisions; it can only use them as a governance layer to guide its output.

Command-Line Mastery with Hopsule CLI

The Hopsule CLI is the preferred tool for senior developers and DevOps engineers who manage context via the terminal or CI/CD pipelines.

1. Use hopsule login to authenticate your terminal session.

2. Run hopsule capsule list to see all available and imported Context Packs.

3. To import a shared pack via a token, use hopsule capsule link --token [YOUR_TOKEN].

4. The CLI features an interactive TUI (Terminal User Interface) with ASCII art that allows you to inspect the status of shared context and view project statistics.

5. In CI/CD pipelines, use the CLI to validate that no unacknowledged decision overrides exist before allowing a build to proceed, ensuring that governance is maintained at the deployment level.

The Role of Hopper in Sharing Context

Hopper is not just a chatbot; it is an advisory layer that lives within the Dashboard and IDE. When you share Context Packs across teams, Hopper assists in the following ways:

• Conflict Detection: If a new Context Pack is imported that contains a decision contradicting an existing local decision, Hopper will flag the conflict and suggest a resolution.

• Drafting Decisions: If you are creating a new Capsule, you can ask Hopper, "Based on our recent project memories, which decisions should be included in a 'Best Practices' Context Pack?"

• Explaining Rationale: When a developer encounters a shared decision they don't understand, they can ask Hopper, "Why was this decision made?" Hopper will synthesize the linked append-only Memories to provide a clear explanation of the organizational judgment.

Tips and Best Practices

• Granularity Matters: Create smaller, focused Context Packs (e.g., "API-Design-Rules") rather than one massive "General-Rules" pack. This allows teams to subscribe only to the context relevant to their specific work.

• Lifecycle Management: Use the Frozen state for Context Packs that represent legacy standards that are still enforced but no longer being updated. Use Historical for packs that are deprecated but kept for preservation and audit trails.

• Memories are Key: Never include a Decision in a shared Capsule without at least one linked Memory. A Decision without reasoning feels like control; a Decision with a Memory is remembrance.

• Regular Audits: Use the Knowledge Graph once a month to ensure that your web of shared context hasn't become overly complex or contradictory.

• Solo Mode: If you are an individual developer, use Context Packs to carry your personal coding standards and architectural preferences from one freelance project to another.

Troubleshooting

Related Articles

• Managing Decision Lifecycles: From Draft to Deprecated

• Configuring IDE Enforcement in Hopsule for VS Code

• Using Hopsule MCP to Power Context-Aware AI Agents