codeninja 2.0.0 → 3.2.0

package/ide/antigravity/.agents/skills/reactjs/SKILL.md

@@ -0,0 +1,211 @@
+---
+skill: reactjs
+scope: reactjs-commands
+loaded-for:
+  - /codeninja:init (reactjs type)
+  - @modularize
+  - @validate-page
+  - @integrate-api
+description: >
+  All technical standards for ReactJS frontend development — file structure,
+  apiClient/apiHandler patterns, encryption inheritance, routing standards,
+  and component conventions. The reactjs-frontend persona uses this skill.
+---
+
+# Skill: ReactJS Frontend
+
+Technical standards for every ReactJS file in this project.
+
+---
+
+## Backend Linking (enforced before any generation)
+
+```
+context.current_init.linked_service     → backend service name
+context.services[linked].port           → REACT_APP_BASE_URL port
+context.services[linked].encryption_key → REACT_APP_KEY
+context.services[linked].encryption_iv  → REACT_APP_IV
+context.services[linked].api_key        → REACT_APP_API_KEY
+```
+
+These 4 values are inherited — NEVER ask the user for them.
+NEVER hardcode any key, IV, or API key value.
+
+---
+
+## apiClient.js — Exact Specification
+
+```javascript
+// src/api/apiClient.js
+// Axios instance — all cross-cutting concerns live here
+
+import axios from 'axios';
+import CryptoJS from 'crypto-js';
+import { logOutRedirectCall, showErrorMessage } from '../pages/common/Utils';
+
+const KEY = CryptoJS.enc.Hex.parse(process.env.REACT_APP_KEY);
+const IV  = CryptoJS.enc.Hex.parse(process.env.REACT_APP_IV);
+
+const axiosClient = axios.create({
+  baseURL: process.env.REACT_APP_BASE_URL,
+  headers: {
+    'api-key': process.env.REACT_APP_API_KEY,
+    'Content-Type': 'text/plain',
+  },
+});
+
+// Request interceptor: encrypt body, attach token
+axiosClient.interceptors.request.use((config) => {
+  const token = localStorage.getItem('wa_token');
+  if (token) {
+    config.headers['token'] = CryptoJS.AES.encrypt(token, KEY, { iv: IV }).toString();
+  }
+  if (config.data) {
+    config.data = CryptoJS.AES.encrypt(JSON.stringify(config.data), KEY, { iv: IV }).toString();
+  }
+  return config;
+});
+
+// Response interceptor: decrypt body
+axiosClient.interceptors.response.use(
+  (response) => {
+    try {
+      const bytes = CryptoJS.AES.decrypt(response.data, KEY, { iv: IV });
+      const parsed = JSON.parse(bytes.toString(CryptoJS.enc.Utf8));
+      if (parsed.status === -1) { logOutRedirectCall(); }
+      return { ...response, data: parsed };
+    } catch {
+      return response;
+    }
+  },
+  (error) => {
+    if (!error.response || error.response.status === 401) {
+      logOutRedirectCall();
+      showErrorMessage('Session expired. Please log in again.');
+    }
+    return Promise.reject(error);
+  }
+);
+
+export default axiosClient;
+```
+
+---
+
+## apiHandler.js — Pattern
+
+```javascript
+// src/api/apiHandler.js
+import axiosClient from './apiClient';
+import { saveWebSession } from '../pages/common/Utils';
+
+// POST /login — authenticate user
+export const webLogin = async ({ email, password }) => {
+  const payload = { email, password, device_type: 'web', device_token: '' };
+  const res = await axiosClient.post('/login', payload);
+  if (res.data.status === 1) saveWebSession(res.data.data);
+  return res.data;
+};
+
+// POST /<path> — description
+export const <functionName> = async (data) => {
+  const res = await axiosClient.post('/<path>', data);
+  return res.data;
+};
+```
+
+Rules:
+- One function per endpoint
+- No try/catch here — interceptors handle errors
+- No decryption here — interceptors handle it
+- Session saving happens in the handler, not in UI components
+- Generate handlers matching `context.api_routes` for the linked service
+
+---
+
+## Component Standards
+
+- Functional components only — no class components
+- JSDoc above every exported function and component
+- No inline styles — `.module.css` per page, `global.css` for shared
+- No `console.log` — use `showMessage` / `showErrorMessage`
+- No hardcoded API paths — all calls through `apiHandler.js`
+
+---
+
+## Welcome Page Standard
+
+```jsx
+// src/pages/Welcome/index.jsx
+import React from 'react';
+import styles from './Welcome.module.css';
+
+/**
+ * Default landing page displayed after app initialisation.
+ * @returns {JSX.Element} Welcome screen with project name.
+ */
+const Welcome = () => (
+  <div className={styles.container}>
+    <h1>{process.env.REACT_APP_PROJECT_NAME || '<project_name>'}</h1>
+    <p>Welcome. Your application is ready.</p>
+  </div>
+);
+
+export default Welcome;
+```
+
+---
+
+## App.jsx Standard
+
+```jsx
+import { BrowserRouter, Routes, Route } from 'react-router-dom';
+import Welcome from './pages/Welcome';
+
+function App() {
+  return (
+    <BrowserRouter>
+      <Routes>
+        <Route path="/" element={<Welcome />} />
+        {/* Additional routes added as project grows */}
+      </Routes>
+    </BrowserRouter>
+  );
+}
+
+export default App;
+```
+
+---
+
+## @modularize Workflow
+
+1. Scan all pages in `src/pages/`
+2. Identify repeated layout blocks (header, footer, sidebar, nav)
+3. Show user: "Found repeated blocks in X pages. Extract to components?"
+4. For each block → create `src/components/<BlockName>/index.jsx` + `.module.css`
+5. Rewrite each page to import and use the component
+6. Never change the page's data-fetching logic or state — layout only
+
+---
+
+## @validate-page Workflow
+
+1. Ask: which page to add validation to
+2. Read the page file
+3. Ask: preferred validation library (validatorjs / Yup / custom)
+4. Add validation on form submit — check required fields, types, formats
+5. Display error messages per field below the input
+6. Never add validation that requires a backend call — client-side only
+
+---
+
+## @integrate-api Workflow
+
+1. Ask: which page to wire up
+2. Read the page file and `src/api/apiHandler.js`
+3. Identify buttons/forms in the page that need API calls
+4. Add the appropriate handler function in `apiHandler.js` if not present
+5. Wire form submit and button clicks to handler functions
+6. Add loading state (boolean), error state (string), success state
+7. Show loading spinner during API call, error message on failure, success feedback on completion

package/ide/antigravity/.agents/workflows/codeninja-api.md

@@ -0,0 +1,111 @@
+---
+slash_command: /codeninja:api
+personas: [global-orchestrator, nodejs-backend]
+skills: [mcp-and-context, api-builder]
+description: Add a new API module (route.js + model.js) to an existing NodeJS service.
+---
+
+# /codeninja:api
+
+## Before Running
+1. Call `context_check_stale`
+2. Call `context_read` — load `context.services` and `context.db.schema`
+3. Read 1–2 existing modules in the target service to understand current patterns
+
+## Execution — Full Step-by-Step
+
+### Phase 0 — Existing Pattern Review
+Before asking any questions, read existing modules in `context.services[<service_name>].modules`
+and scan 1–2 existing `route.js` and `_model.js` files from the service.
+
+Identify:
+- Naming conventions (camelCase vs PascalCase)
+- Common validation patterns
+- Auth patterns (all protected? mixed?)
+- Response patterns beyond standard contract
+
+Surface: "I've reviewed [n] existing modules. I'll follow the same structure." Then proceed.
+
+---
+
+### Phase 1 — Target Service
+
+**Step 1.** Ask: "Which service?" (list from `context.services`)
+- Store: `context.current_api.service_name`
+
+**Step 2.** Ask: "API version?" (default: v1)
+- Store: `context.current_api.version`
+
+---
+
+### Phase 2 — Module Identity
+
+**Step 3.** Ask: "Module name?" (e.g. Products, Orders, Invoice)
+- Store: `context.current_api.module_name`
+
+**Step 4.** Ask: "HTTP method?" (GET / POST / PUT / PATCH / DELETE)
+- Store: `context.current_api.method`
+
+**Step 5.** Ask: "Route path?" (e.g. /products, /products/:id)
+- Store: `context.current_api.route_path`
+
+**Step 6.** Ask: "Route description?" (one sentence)
+- Store: `context.current_api.description`
+
+---
+
+### Phase 3 — Database Binding
+
+**Step 7.** Ask: "Which table does this route primarily use?"
+- Show available tables from `context.db.schema.tables`
+- Store: `context.current_api.primary_table`
+
+**Step 8.** Ask: "Does this route require authentication?" (yes / no)
+- Store: `context.current_api.requires_auth`
+
+---
+
+### Phase 4 — Confirm and Generate
+
+**Step 9.** Confirm: "Generate [METHOD] [path] in [service]/modules/[version]/[Module]? (yes/no)"
+
+**Step 10.** Delegate to nodejs-agent — generate ALL files simultaneously:
+
+- `modules/<version>/<ModuleName>/route.js`
+  - Full validation schema using `validatorjs`
+  - All middleware applied in correct order
+  - Calls model function, returns via `sendResponse`
+  - JSDoc on every handler
+
+- `modules/<version>/<ModuleName>/<module>_model.js`
+  - Parameterized queries only — no string concatenation
+  - References actual column names from `context.db.schema`
+  - Returns exactly `{ responsecode, responsemsg, responsedata }`
+  - No `res.json()` anywhere in this file
+
+- Append to `modules/<version>/route_manager.js`
+  - Use `file_insert_after` MCP tool — NEVER rewrite this file
+  - Surgical insert of `router.use('/<path>', require('./<Module>/route'))` only
+  - Use `file_contains` first to avoid duplicate registration
+
+- Patch `document/<version>/swagger_doc.json`
+  - Use `file_insert_after` MCP tool — NEVER rewrite this file
+  - Add new path key to the `paths` object only
+
+---
+
+### Phase 5 — Finalize
+
+**Step 11.** Call `context_write`:
+- Append to `context.api_routes`
+- Update `context.services[<service>].modules`
+- Set `last_command` = "create-api"
+- Append to `change_log`
+
+**Step 12.** Call `context_clear_scratchpad` with keys: ["current_api"]
+
+**Step 13.** Show final summary:
+- Files created/modified
+- Route registered in route_manager
+- Swagger patched
+- Offer next steps: /codeninja:design, /codeninja:db:create

package/ide/antigravity/.agents/workflows/codeninja-audit.md

@@ -0,0 +1,81 @@
+---
+slash_command: /codeninja:audit
+personas: [global-orchestrator, nodejs-backend]
+skills: [mcp-and-context, api-builder, code-intelligence]
+description: Deep security and quality review of an existing NodeJS service.
+---
+
+# /codeninja:audit
+
+## Before Running
+1. Call `context_read`
+2. Call `context_check_stale`
+
+## Execution — Full Step-by-Step
+
+**Step 1.** Ask: "Which service to audit?" (list from `context.services`)
+
+**Step 2.** Delegate to nodejs-agent. Run all checks:
+
+### Security Checks
+- [ ] API key validation middleware on ALL routes?
+- [ ] Input validation on all POST/PUT/PATCH routes?
+- [ ] SQL injection prevention (parameterized queries only)?
+- [ ] Sensitive values only from env vars (no hardcoded keys/passwords)?
+- [ ] `.env` in `.gitignore`?
+- [ ] Real AES-256-CBC encryption (not base64)?
+- [ ] `utilities/encryption.js` is the ONLY file importing crypto-js or cryptlib?
+- [ ] `res.json()` never called directly in route.js or model files?
+- [ ] Validator package never imported directly in route files?
+- [ ] SMTP credentials only in .env — never hardcoded in notification.js or template.js?
+- [ ] Firebase service account file in `pem/` and in `.gitignore`?
+- [ ] `GLOBALS` object frozen using `Object.freeze()`?
+
+### Code Quality Checks
+- [ ] Only services called from controllers (no DB queries in controllers)?
+- [ ] Models contain only DB queries and business logic?
+- [ ] Global error handler present and used?
+- [ ] All routes call `checkValidationRules` from `utilities/validator.js`?
+- [ ] No separate `_validator.js` files per module?
+- [ ] `rateLimiter` is FIRST middleware in `route_manager.js`?
+- [ ] `extractLanguage` runs BEFORE `validateApiKey` in `route_manager.js`?
+- [ ] `decryptRequest` is LAST middleware in the chain?
+- [ ] No route handlers defined directly in `route_manager.js`?
+- [ ] `asyncHandler` wraps every middleware in `route_manager.js`?
+- [ ] All model functions return exactly `{ responsecode, responsemsg, responsedata }`?
+- [ ] No `req/res` objects in any model file?
+- [ ] Passwords encrypted via `utilities/encryption.js` before storage?
+- [ ] Session tokens generated only via `common.generateSessionCode()`?
+
+### Consistency Checks
+- [ ] All routes documented in `swagger_doc.json`?
+- [ ] Response format consistent (success, message, data, timestamp)?
+- [ ] snake_case for DB, camelCase for JS?
+- [ ] Port matches `context.services[<n>].port`?
+- [ ] DB config matches `context.db`?
+- [ ] All message keywords in `sendResponse` calls exist in `languages/en.js`?
+- [ ] All language files have the same keys as `en.js`?
+- [ ] No two services share the same port in context.services?
+- [ ] All encryption keys exactly 32 chars in context.services?
+- [ ] All encryption IVs exactly 16 chars in context.services?
+
+### Context Alignment
+- [ ] All routes present in `context.api_routes`?
+- [ ] All DB tables referenced match `context.db.schema`?
+- [ ] All `router.use()` lines in route_manager.js have a corresponding entry in context.services modules?
+- [ ] All context.services modules have a corresponding `router.use()` in route_manager.js?
+- [ ] All swagger_doc.json paths have a corresponding entry in context.api_routes?
+
+**Step 3.** Present audit report:
+```
+AUDIT REPORT — <service_name>
+══════════════════════════════════════
+🔴 CRITICAL   (must fix)
+🟡 WARNING    (should fix)
+🟢 INFO       (nice to have)
+══════════════════════════════════════
+[list findings with file + line context]
+```
+
+**Step 4.** Ask: "Auto-fix critical issues? (yes/no)"
+If yes → delegate to nodejs-agent for fixes → call `context_write` after.

package/ide/antigravity/.agents/workflows/codeninja-db-create.md

@@ -0,0 +1,124 @@
+---
+slash_command: /codeninja:db:create
+personas: [global-orchestrator, database-architect]
+skills: [mcp-and-context, database]
+description: Design and generate a new database table with migration file.
+---
+
+# /codeninja:db:create
+
+## Before Running
+1. Call `context_read` — load `context.db` fully
+2. Call `context_check_stale`
+3. Call `migration_next_number` MCP tool — get next sequential migration number
+
+## Execution — Full Step-by-Step
+
+### Phase 1 — Table Identity
+
+**Step 1.** Ask: "What is this table for?" (free text — used by agent for suggestions)
+- Store: `context.current_db.table_purpose`
+
+**Step 2.** Ask: "Table name?" (must start with `tbl_`, snake_case, lowercase)
+- Enforce prefix and casing
+- Store: `context.current_db.table_name`
+
+**Step 3.** Ask: "Migration file number?" (agent reads migrations/ and suggests next)
+- Call `migration_next_number` to get suggestion
+- Store: `context.current_db.file_number`
+
+---
+
+### Phase 2 — Standard Columns Decision
+
+**Step 4.** Ask: "Does this table need `status` and `is_deleted` columns?"
+- Suggest YES for user/entity tables, NO for event/log tables
+- Store: `context.current_db.needs_status`
+
+**Step 5.** Ask: "Does this table support soft delete (`is_deleted`)?"
+- Auto-suggest YES if needs_status is YES
+- Store: `context.current_db.needs_soft_delete`
+
+---
+
+### Phase 3 — Column Collection (repeat until done)
+
+**Step 6.** Ask: "Enter next column name (or type 'done' to finish):"
+- Show columns collected so far
+- Enforce: snake_case, lowercase
+- Append to: `context.current_db.columns[]`
+
+**Step 7.** Ask: "Column type?" — show type suggestion based on name pattern:
+- `*_id` → BIGINT NOT NULL DEFAULT 0 (also check for FK — ask if foreign key)
+- `is_*` → BOOLEAN NOT NULL DEFAULT FALSE
+- `*_at` → TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+- `status` → INTEGER NOT NULL DEFAULT 0 CHECK (status IN (0,1))
+- `*_count` → BIGINT NOT NULL DEFAULT 0
+- `*_price`, `*_amount` → NUMERIC(18,8) NOT NULL DEFAULT 0.00000000
+- `email` → VARCHAR(132) NOT NULL DEFAULT ''
+- `phone` → VARCHAR(16) NOT NULL DEFAULT ''
+- `password` → TEXT NOT NULL DEFAULT ''
+- `*_image`, `*_url` → VARCHAR(255) NOT NULL DEFAULT ''
+- `payload`, `metadata`, `*_result` → JSON NOT NULL DEFAULT '{}'
+- default → VARCHAR(255) NOT NULL DEFAULT ''
+
+**Step 8.** Ask: "Does this column have a fixed set of allowed values? (enum-like)"
+- If yes → ask for the allowed values and generate a CHECK constraint + COMMENT
+
+**Step 9.** Return to Step 6 until user types 'done'
+
+---
+
+### Phase 4 — Index Decision
+
+**Step 10.** Agent auto-suggests indexes based on collected columns:
+- Every `*_id` (FK) column → suggest index
+- `status + is_deleted` compound → suggest if both exist
+- `created_at DESC` → suggest for event/log tables
+Ask user to confirm suggested indexes or add custom ones.
+
+---
+
+### Phase 5 — Seed Data
+
+**Step 11.** Ask: "Does this table need initial/seed data?"
+- Guide: suggest YES only for reference/master data tables
+- If yes → collect row values column by column, repeat per row
+- Store: `context.current_db.seed_rows[]`
+
+---
+
+### Phase 6 — Summary and Generate
+
+**Step 12.** Show complete table definition:
+- Table name, file number, all columns with types, indexes, seed rows
+- Ask: "Generate this table? (yes / no / change a value)"
+- If change → re-run specific step → return to summary
+- If no → abort
+- If yes → proceed
+
+**Step 13.** Delegate to database-agent:
+- Generate: `<repo_root>/database/<db_type>/migrations/<number>-setup-tbl-<n>.sql`
+  - File header comment
+  - `BEGIN;`
+  - Standard system columns: `id BIGSERIAL PRIMARY KEY`
+  - All collected columns in order
+  - `status INTEGER NOT NULL DEFAULT 0 CHECK (status IN (0,1))` if needs_status
+  - `is_deleted BOOLEAN NOT NULL DEFAULT FALSE` if needs_soft_delete
+  - `created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP`
+  - All CHECK constraints and COMMENTs for enum columns
+  - All per-table CREATE INDEX statements
+  - GRANT SELECT, INSERT, UPDATE, DELETE to `<db_user>`
+  - Seed data INSERT if collected
+  - `COMMIT;`
+- Update: `<repo_root>/database/<db_type>/create-schema.sql` (add `\i` entry in order)
+- If any indexes belong in shared file → update `111-setup-database-indexes.sql`
+
+**Step 14.** Call `context_write`:
+- Append table to `context.db.schema.tables`
+- Append to `context.db.schema.change_log`
+- Clear `context.current_db`
+
+**Step 15.** Call `context_clear_scratchpad` with keys: ["current_db"]
+
+**Step 16.** Show final summary with file path and next steps.

package/ide/antigravity/.agents/workflows/codeninja-db-drop.md

@@ -0,0 +1,87 @@
+---
+slash_command: /codeninja:db:drop
+personas: [global-orchestrator, database-architect]
+skills: [mcp-and-context, database]
+description: Generate a DROP TABLE migration. Never deletes the original setup file.
+---
+
+# /codeninja:db:drop
+
+## Before Running
+1. Call `context_read` — load `context.db.schema`
+2. Call `context_check_stale`
+
+## Execution — Full Step-by-Step
+
+### Phase 1 — Target
+
+**Step 1.** Ask: "Which table to drop?" (list from `context.db.schema.tables`)
+- Store: `context.current_db.table_name`
+
+---
+
+### Phase 2 — Impact Analysis
+
+**Step 2.** Agent scans context:
+- Check `context.api_routes` for routes referencing this table as `primary_table`
+- Check `context.services` for modules using this table
+- Check `context.db.schema.tables` for FK columns pointing to this table
+
+**Step 3.** If references found, display warning:
+```
+⚠ WARNING: This table is referenced by:
+  - [service]/modules/[Module] (primary_table)
+  - tbl_<other_table>.<col> → <this_table> (FK dependency)
+
+Dropping this table will break these references.
+Make sure to update or remove dependent code first.
+```
+Ask: "Do you still want to proceed? (yes / no)"
+If no → abort.
+
+**Step 4.** Final confirmation:
+Ask: "Type the table name to confirm the drop."
+Must match exactly — if wrong → abort.
+
+---
+
+### Phase 3 — File Numbering
+
+**Step 5.** Ask: "Migration file number?" (suggest next available)
+- Store: `context.current_db.file_number`
+
+---
+
+### Phase 4 — Generate
+
+**Step 6.** Delegate to database-agent:
+Generate: `<repo_root>/database/<db_type>/migrations/<number>-drop-tbl-<n>.sql`
+
+```sql
+-- Drop tbl_<table_name>
+-- Migration: <number>-drop-tbl-<n>.sql
+-- Generated: <ISO date>
+-- WARNING: This migration is irreversible in production.
+-- Original table definition: <original_setup_file>
+
+BEGIN;
+
+DROP TABLE IF EXISTS public.<table_name> CASCADE;
+
+COMMIT;
+```
+
+Update `create-schema.sql`:
+- Keep the original `\i <setup_file>` entry
+- Add the drop file entry AFTER it (never remove original)
+
+**Step 7.** Call `context_write`:
+- Snapshot full column list before removing from active tables
+- Append to `context.db.schema.change_log`:
+  `{ type: "table_dropped", table: "<n>", snapshot: { full column list }, file: "<path>" }`
+- Remove table from `context.db.schema.tables`
+- Clear `context.current_db`
+
+**Step 8.** Call `context_clear_scratchpad` with keys: ["current_db"]
+
+**Step 9.** Show final summary.

package/ide/antigravity/.agents/workflows/codeninja-db-index.md

@@ -0,0 +1,70 @@
+---
+slash_command: /codeninja:db:index
+personas: [global-orchestrator, database-architect]
+skills: [mcp-and-context, database]
+description: Add a new index to an existing table.
+---
+
+# /codeninja:db:index
+
+## Before Running
+1. Call `context_read` — load `context.db.schema`
+2. Call `context_check_stale`
+
+## Execution — Full Step-by-Step
+
+### Phase 1 — Target Table
+
+**Step 1.** Ask: "Which table?" (list from `context.db.schema.tables`)
+- Store: `context.current_db.table_name`
+
+### Phase 2 — Index Columns
+
+**Step 2.** Ask: "Which column(s) for this index?"
+- List available columns from `context.db.schema.tables[<table>].columns`
+- Allow one or multiple (compound index)
+- Store: `context.current_db.index_columns[]`
+
+**Step 3.** Ask: "Should any column be sorted DESC?" (common: `created_at DESC`, `time DESC`)
+- If yes → ask which column(s)
+- Store: `context.current_db.index_desc_columns[]`
+
+**Step 4.** Ask: "Standard or partial index?"
+- Standard: covers all rows
+- Partial: only rows matching a WHERE condition — if partial, ask for WHERE clause
+- Store: `context.current_db.index_where_clause`
+
+### Phase 3 — File Placement
+
+**Step 5.** Ask: "Where should this index be defined?"
+1. In the table's own setup file (for new/just-created tables)
+2. In `111-setup-database-indexes.sql` (for existing tables — auto-suggested)
+- Store: `context.current_db.index_file`
+
+### Phase 4 — Generate
+
+**Step 6.** Agent auto-generates index name:
+- In table file: `idx_<table_without_tbl_prefix>_<columns_joined>`
+- In shared file: `idx_tbl_<table_without_tbl_prefix>_<columns_joined>`
+- Show: "Index will be named: <name> — OK? (yes / rename)"
+
+**Step 7.** Confirm: "Generate this index? (yes / no)"
+
+**Step 8.** Delegate to database-agent:
+```sql
+--
+-- Name: <index_name>; Type: INDEX; Schema: public
+--
+CREATE INDEX <index_name> ON public.<table_name> (<col> [DESC], ...)
+  [WHERE <where_clause>];
+```
+Append to correct file (table setup file OR `111-setup-database-indexes.sql`).
+
+**Step 9.** Call `context_write`:
+- Append index to `context.db.schema.tables[<table>].indexes`
+- Append to `context.db.schema.change_log`
+- Clear `context.current_db`
+
+**Step 10.** Call `context_clear_scratchpad` with keys: ["current_db"]
+
+**Step 11.** Show final summary.