jumpstart-mode 1.1.13 → 1.1.14

package/.jumpstart/skills/mcp-server-designer/templates/mcp-server-design-template.md

@@ -0,0 +1,115 @@
+# MCP Server Design: <Domain>
+
+**Owner:** <name>
+**Date:** <YYYY-MM-DD>
+**Version:** 1.0.0
+
+## Executive summary
+
+- Domain: <business domain>
+- Tools: <N>
+- Resources: <N>
+- Prompts: <N>
+- Auth model: <OAuth / API key / managed identity>
+
+## Tool catalog
+
+| # | Name | Description | Side effects | Auth scope | Rate limit | Irreversible |
+|---|---|---|---|---|---|---|
+| 1 | | | read_only / creates / modifies / deletes / external_call | | /min | Y/N |
+
+### Tool: <tool_name>
+
+**Description:** <what it does in business terms>
+
+**Input schema:**
+```json
+{
+  "type": "object",
+  "properties": {
+    "param1": { "type": "string", "description": "..." }
+  },
+  "required": ["param1"]
+}
+```
+
+**Output schema:**
+```json
+{
+  "type": "object",
+  "properties": {
+    "status": { "type": "string", "enum": ["success", "error"] },
+    "data": { "type": "object" }
+  }
+}
+```
+
+**Error codes:**
+| Code | Meaning | Retryable |
+|---|---|---|
+| | | Y/N |
+
+**Idempotency:** <key / natural dedup / not idempotent>
+
+(Repeat per tool.)
+
+## Resource catalog
+
+| # | URI pattern | Content type | Access scope | Freshness | Paginated |
+|---|---|---|---|---|---|
+| 1 | | application/json / text/markdown | | real-time / max_age N s | Y/N |
+
+## Prompt catalog
+
+| # | Name | Description | Arguments | Use case |
+|---|---|---|---|---|
+| 1 | | | | |
+
+## Auth and identity design
+
+- Agent authentication: <method>
+- User context passing: <claim / header / parameter>
+- Tool-level elevation: <which tools need higher scope>
+- Token refresh: <mechanism>
+
+## Rate limit and concurrency
+
+| Tier | Limit | Scope |
+|---|---|---|
+| Default | /min per agent | |
+| Elevated | /min per agent | (requires approval) |
+
+## Error contract
+
+Standard envelope:
+```json
+{
+  "error": {
+    "code": "RESOURCE_NOT_FOUND",
+    "message": "...",
+    "retry_after_seconds": null
+  }
+}
+```
+
+## Versioning and deprecation
+
+- Current version: 1.0.0
+- Deprecation notice period: <N days before removal>
+- Breaking change policy: <major version bump + migration guide>
+
+## Operational monitoring
+
+- Metrics: tool call count, latency p50/p95, error rate, auth failures.
+- Alerts: error rate > X%, latency > Yms, auth failures > Z/min.
+- Health check: <resource URI or endpoint>
+
+## Architecture diagram
+
+```mermaid
+flowchart LR
+    AgentA[Agent A] -->|MCP| Server[MCP Server]
+    AgentB[Agent B] -->|MCP| Server
+    Server -->|API| Backend[(Backend System)]
+    Server -->|DB| Database[(Database)]
+```

package/.jumpstart/skills/memory-architecture-designer/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: memory-architecture-designer
+description: 'Design the memory architecture for an AI agent or copilot — short-term, long-term, episodic, semantic, profile, and tool memory — with explicit scope, TTL, PII boundaries, and write/read policy. Use this whenever the user is shaping how an agent remembers things across turns, sessions, users, or tenants, even when phrased as "make the bot remember", "give it long-term memory", "personalize the assistant", or "store conversation context".'
+argument-hint: 'Provide the use case, the user model (single-user, multi-user, multi-tenant), what should persist, sensitivity constraints, and platform.'
+---
+
+# Memory Architecture Designer
+
+## Positioning
+
+"Add memory" is the most overloaded request in agent design. It bundles at least four things — conversation context, user preferences, learned facts, and tool/RAG state — that have different scopes, TTLs, and risk profiles. Use this skill to separate them, decide what is actually persisted, and design the read/write policy so the agent helps without leaking, drifting, or pretending to know things it does not.
+
+## When To Use This
+
+- Shaping an agent or copilot that should "remember" anything beyond a single turn.
+- Personalization is creeping into scope and the team needs to commit to a memory model.
+- Privacy, residency, or multi-tenant constraints make ad-hoc memory unsafe.
+- Agent quality is degrading because old context is bleeding into new tasks.
+
+## When Not To Use This
+
+- Do not use this for a stateless single-turn classifier or extractor.
+- Do not use this in place of [`privacy-by-design-for-ai`](../privacy-by-design-for-ai/SKILL.md) for the DPIA-style review; pair them.
+- Do not use this in place of [`rag-architecture-designer`](../rag-architecture-designer/SKILL.md) for the corpus retrieval design — those are different memories.
+
+## The Memory Types
+
+| Type | Scope | TTL | Examples | Risk |
+|---|---|---|---|---|
+| Working / context window | Current turn | seconds | Most recent messages, retrieved chunks | Low |
+| Short-term / session | Current session | minutes–hours | Conversation summary, in-progress task state | Low–medium (PII in chat) |
+| Long-term episodic | Per user, durable | days–years | "Last time I helped you with X" | High (PII, drift) |
+| Long-term semantic | Per user/tenant, durable | days–years | Learned preferences, jargon, profile facts | High |
+| Profile | Per user | until changed | Name, role, language, accessibility settings | Medium–high |
+| Tool / world state | Per tenant | varies | Cached search results, tool outputs | Low–medium |
+| Cross-user / shared | Tenant-wide | varies | FAQs, learned answers, shared knowledge | High (privacy) |
+
+See [references/memory-pattern-library.md](./references/memory-pattern-library.md) for canonical patterns and PII boundaries.
+
+## Workflow
+
+1. List what the team wants the agent to "remember" in plain language.
+2. Map each item to a memory type with an explicit scope, TTL, and storage location.
+3. Decide what is *not* persisted (most of the conversation history).
+4. Define the write policy: who/what writes, with what consent, with what redaction.
+5. Define the read policy: who/what reads, with what scope filter (per user, per tenant), with what trust level.
+6. Define the forget mechanism: user-initiated, time-based, regulator-driven (right to erasure).
+7. Capture in [templates/memory-architecture-spec.md](./templates/memory-architecture-spec.md) including a data flow diagram.
+8. Pressure-test against multi-tenant leakage, PII drift, and "agent says wrong thing because it remembered something stale" failure modes.
+
+## Output Structure
+
+1. Use case and user model.
+2. Memory inventory by type.
+3. Write policy and consent surface.
+4. Read policy and scope filters.
+5. Forget mechanism.
+6. PII and sensitivity handling.
+7. Storage and residency.
+8. Observability (memory hits, staleness, leakage signals).
+9. Risks, assumptions, next validation.
+
+A worked output is in [examples/example-multi-tenant-copilot-memory.md](./examples/example-multi-tenant-copilot-memory.md).
+
+## Common Pitfalls
+
+- **One blob "memory" per user.** Mixes preferences, conversation, and learned facts; impossible to govern.
+- **No forget path.** Right-to-erasure compliance fails; users cannot recover from a wrong memory.
+- **Cross-tenant shared memory by accident.** Shared cache without tenant scoping leaks across customers.
+- **Stale episodic memory.** "Last time" memories that do not reflect the current world degrade quality.
+- **Free-form long-term memory written from raw chat.** PII is captured; the agent confidently restates outdated facts.
+- **No consent surface.** Persisting personalization without user awareness fails GDPR/CPRA-style rules.
+- **Memory as RAG substitute.** Putting documents in "memory" instead of an indexed corpus.
+
+## Quality Bar
+
+- Each remembered item names its type, scope, TTL, and storage.
+- Read and write policies are explicit and enforced (not "trust the agent").
+- A forget mechanism exists and works.
+- Multi-tenant scoping is enforced at storage and at retrieval.
+
+## Related Skills
+
+- `privacy-by-design-for-ai` — DPIA overlay on the memory plan.
+- `rag-architecture-designer` — corpus memory belongs there.
+- `agent-permissioning-designer` — identity and scope on memory reads.
+- `agent-governance` — policy on what may be remembered and where.
+- `observability-design-for-ai` — instrument memory hits and staleness.

package/.jumpstart/skills/memory-architecture-designer/evals/evals.json

@@ -0,0 +1,32 @@
+{
+  "skill_name": "memory-architecture-designer",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "We want our employee assistant to 'remember things across sessions' so it feels personal. ~10k employees, single tenant, EU residency. Design the memory architecture and tell us how to keep it safe.",
+      "expected_output": "A memory architecture spec separating types, with explicit write/read/forget policies and EU residency.",
+      "expectations": [
+        "Separates working, session, episodic, semantic, profile, and tool-state memory rather than one blob.",
+        "Maps each item to scope, TTL, storage, and sensitivity.",
+        "Specifies a curator pass for episodic/semantic writes with PII redaction; never persists raw chat.",
+        "Names a forget mechanism including right-to-erasure for GDPR.",
+        "Enforces EU residency at storage and recommends per-region stores.",
+        "Includes observability for staleness, cross-tenant safety (single tenant here, but scope filters explicit), and drift.",
+        "Calls out risks like memory drift and unauthorized re-disclosure of personal facts."
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "Our SaaS copilot's 'memory' is one Mongo doc per user with the last 200 messages and any facts we extracted. We're seeing wrong facts persist and a couple of cross-tenant complaints. Diagnose and propose a redesign.",
+      "expected_output": "A diagnosis identifying the failure modes and a redesign with separated types, scoping, and forget paths.",
+      "expectations": [
+        "Diagnoses one-blob memory as the root cause: type mixing, no curator, no scope filters, no forget.",
+        "Identifies the cross-tenant complaint risk as missing scope enforcement at storage and retrieval and recommends a fix.",
+        "Recommends separating session, episodic, and semantic memories with distinct stores or partitions.",
+        "Adds a curator step with redaction and confirmation for high-stakes facts.",
+        "Adds a forget API and right-to-erasure cascade including embeddings and summaries.",
+        "Adds observability: cross-tenant leak detection, staleness signals, drift watch."
+      ]
+    }
+  ]
+}

package/.jumpstart/skills/memory-architecture-designer/examples/example-multi-tenant-copilot-memory.md

@@ -0,0 +1,46 @@
+# Example: Multi-Tenant Onboarding Copilot Memory
+
+## Use case and user model
+B2B SaaS onboarding copilot. Tenants are customer companies; users are employees of those tenants. Profile lives in the SaaS product.
+
+## Memory inventory
+| Item | Type | Scope | TTL | Storage | Sensitivity | Owner |
+|---|---|---|---|---|---|---|
+| Recent messages | Working | turn | seconds | in-process | low | runtime |
+| Conversation summary | Session | session_id | 24h | Redis | low | runtime |
+| Onboarding stage / next step | Session | session_id + user | end of onboarding | Cosmos | low | product |
+| User language preference | Profile | user | until changed | product profile | low | product |
+| Tenant glossary (terms, jargon) | Shared semantic | tenant | curator-managed | Cosmos | medium (IP) | tenant admin |
+| "Last helped you with" | Episodic | user | 90d | Cosmos | medium (PII risk) | curator |
+| Tool result cache | World state | tenant | 10m | Redis | low | runtime |
+
+## Write policy
+- Episodic and semantic facts written by a curator pass; raw chat is not persisted.
+- Curator redacts emails, phone, account numbers before persistence.
+- User language preference written only when user explicitly sets it.
+- Tenant glossary additions require tenant admin approval.
+
+## Read policy
+- All reads scoped by tenant ID; tenant filter enforced at storage and at retriever.
+- User-scoped memories require user ID match.
+- Staleness: episodic > 90d marked stale and not surfaced unless asked.
+
+## Forget mechanism
+- User self-serve "forget my history" purges episodic + session memory and embeddings.
+- Right-to-erasure on tenant offboarding cascades to all stores within 30 days.
+- TTL enforced by Cosmos TTL policies and Redis expirations.
+
+## PII and sensitivity
+- No PHI/PCI captured.
+- PII captured only in profile from product source; not derived from chat.
+- Residency: per-tenant region selection; memory stores deployed regionally.
+
+## Observability
+- Per call: log memory_types_read, hits, staleness flags.
+- Cross-tenant leak detection: alert if a read returns a record whose tenant != caller tenant.
+- Drift signal: % of episodic facts marked stale by user as "no longer true".
+
+## Risks, assumptions, next validation
+- Risk: tenant glossary becomes a privacy hazard if employees contribute personal data; mitigate with admin curator and PII scan.
+- Assumption: product profile is the source of truth for user language and role.
+- Next: tabletop test for tenant offboarding cascade.

package/.jumpstart/skills/memory-architecture-designer/references/memory-pattern-library.md

@@ -0,0 +1,60 @@
+# Memory Pattern Library
+
+## Working memory
+- Compose the prompt: system + policy + retrieved + recent turns.
+- Trim with a deterministic policy (last N turns, sliding window with summary).
+- Never let user content override system instructions.
+
+## Short-term / session memory
+- Conversation summary written every K turns by a small model.
+- Stored under session ID; expires at session end or after TTL.
+- Useful for multi-turn tasks; not for personalization.
+
+## Long-term episodic
+- Discrete records: "On <date>, helped user with <task>; outcome: <X>."
+- Schema-backed; not free-form text.
+- Aged out by relevance and recency; retrieval scoped to user.
+- Risk: drift if not refreshed; PII if from raw chat.
+
+## Long-term semantic
+- Distilled facts/preferences: language, role, recurring jargon.
+- Written through a curator step (extract → validate → confirm with user where appropriate).
+- Replaceable, not append-only; a fact has one current value.
+
+## Profile
+- Authoritative source: identity provider or product profile.
+- Memory mirrors but does not own.
+- Changes flow from source to memory, not the other way.
+
+## Tool / world state cache
+- Tenant-scoped; TTL by data freshness.
+- Used to avoid repeated tool calls in the same task.
+
+## Shared / org memory
+- Curated; not auto-derived from user chat.
+- Access controlled per tenant and group.
+- High PII risk if auto-derived; require curator + DPIA review.
+
+## Write policy patterns
+- **Curator step** — separate model run that decides if a fact is worth persisting and validates it.
+- **User confirmation** — for high-stakes facts (preferences, role), confirm before write.
+- **Redaction at write** — pass through PII redactor before persistence; never persist raw chat.
+- **Append-only audit log + replaceable current state** — record changes, expose current.
+
+## Read policy patterns
+- **Scope-first retrieval** — never read across tenant or user boundaries; enforce in storage filter.
+- **Trust tiering** — semantic facts above episodic above raw retrieved content.
+- **Staleness check** — attach `last_validated_at` and refuse old facts above threshold.
+
+## Forget patterns
+- **TTL** — time-based expiry, configurable per type.
+- **User-initiated** — "forget X" surface; verifies and removes.
+- **Right-to-erasure** — full export and delete on regulator-driven request.
+- **Cascading delete** — remove from index, embeddings, summaries, and any derivative.
+
+## Storage choices (typical)
+- Working: in-process / orchestration framework.
+- Session: Redis, Cosmos DB, DynamoDB.
+- Episodic + semantic: Cosmos DB, Postgres, Mongo with vector index.
+- Cache: Redis with TTL.
+- Audit log: append-only WORM-friendly store.

package/.jumpstart/skills/memory-architecture-designer/templates/memory-architecture-spec.md

@@ -0,0 +1,55 @@
+# Memory Architecture Spec — `<assistant>`
+
+## Use case and user model
+- Single-user / multi-user / multi-tenant:
+- Authoritative profile source:
+
+## Memory inventory
+| Item | Type | Scope | TTL | Storage | Sensitivity | Owner |
+|---|---|---|---|---|---|---|
+
+## Write policy
+- Trigger:
+- Writer (LLM curator, deterministic, user-confirmed):
+- Redaction at write:
+- Consent surface:
+
+## Read policy
+- Scope filter:
+- Trust tiering:
+- Staleness threshold:
+
+## Forget mechanism
+- TTL per type:
+- User-initiated forget:
+- Right-to-erasure flow:
+- Cascading deletes:
+
+## PII and sensitivity handling
+- Classes captured / not captured:
+- Redaction rules:
+- Residency:
+
+## Observability
+- Memory hits per call (logged):
+- Staleness warnings:
+- Cross-tenant leak detection:
+- Drift signals:
+
+## Diagram
+
+```mermaid
+flowchart LR
+  U[User] --> A[Agent]
+  A --> WM[Working memory]
+  A --> SM[Session memory]
+  A --> LE[Episodic store]
+  A --> LS[Semantic store]
+  A --> P[Profile (read-only)]
+  C[Curator] --> LE
+  C --> LS
+  F[Forget API] --> LE
+  F --> LS
+```
+
+## Risks, assumptions, next validation