@researchdatabox/redbox-dev-tools 0.0.1-beta.10173

package/dist/utils/hook-tsconfig.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHookCompilerOptions = createHookCompilerOptions;
+exports.createHookTsConfig = createHookTsConfig;
+exports.cleanupHookTsConfig = cleanupHookTsConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const module_1 = require("module");
+function toPosixPath(value) {
+    return value.split(path_1.default.sep).join('/');
+}
+function getPackageRequire(packageName) {
+    const packageJsonPath = packageName === '@researchdatabox/redbox-dev-tools'
+        ? path_1.default.resolve(__dirname, '..', '..', 'package.json')
+        : require.resolve(`${packageName}/package.json`);
+    return (0, module_1.createRequire)(packageJsonPath);
+}
+function resolvePackageDir(resolver, request) {
+    try {
+        return path_1.default.dirname(resolver.resolve(`${request}/package.json`));
+    }
+    catch {
+        return null;
+    }
+}
+function collectPathEntries(projectDir, entries) {
+    return entries
+        .filter((entry) => Boolean(entry))
+        .map(entry => toPosixPath(path_1.default.relative(projectDir, entry)))
+        .filter((entry, index, all) => entry.length > 0 && all.indexOf(entry) === index);
+}
+function getHookCompilerOptions(projectDir, projectTsconfig) {
+    const projectRequire = (0, module_1.createRequire)(projectTsconfig);
+    const redboxCoreRequire = getPackageRequire('@researchdatabox/redbox-core');
+    const redboxDevToolsRequire = getPackageRequire('@researchdatabox/redbox-dev-tools');
+    const redboxDevToolsDir = path_1.default.resolve(__dirname, '..', '..');
+    const localNodeTypes = path_1.default.join(projectDir, 'node_modules', '@types');
+    const devToolsNodeTypes = path_1.default.join(redboxDevToolsDir, 'node_modules', '@types');
+    const sailsNgCommonDirs = [
+        resolvePackageDir(redboxCoreRequire, '@researchdatabox/sails-ng-common'),
+        resolvePackageDir(projectRequire, '@researchdatabox/sails-ng-common'),
+        resolvePackageDir(redboxDevToolsRequire, '@researchdatabox/sails-ng-common'),
+    ];
+    const axiosDirs = [
+        resolvePackageDir(redboxCoreRequire, 'axios'),
+        resolvePackageDir(projectRequire, 'axios'),
+        resolvePackageDir(redboxDevToolsRequire, 'axios'),
+    ];
+    const rxjsDirs = [
+        resolvePackageDir(redboxCoreRequire, 'rxjs'),
+        resolvePackageDir(projectRequire, 'rxjs'),
+        resolvePackageDir(redboxDevToolsRequire, 'rxjs'),
+    ];
+    const lodashDirs = [
+        resolvePackageDir(redboxCoreRequire, 'lodash'),
+        resolvePackageDir(projectRequire, 'lodash'),
+        resolvePackageDir(redboxDevToolsRequire, 'lodash'),
+    ];
+    return {
+        baseUrl: '.',
+        paths: {
+            '@researchdatabox/sails-ng-common': collectPathEntries(projectDir, sailsNgCommonDirs),
+            axios: collectPathEntries(projectDir, axiosDirs),
+            rxjs: collectPathEntries(projectDir, rxjsDirs),
+            'rxjs/*': collectPathEntries(projectDir, rxjsDirs.map(entry => entry ? path_1.default.join(entry, '*') : null)),
+            lodash: collectPathEntries(projectDir, lodashDirs),
+        },
+        typeRoots: [
+            fs_1.default.existsSync(localNodeTypes) ? toPosixPath(path_1.default.relative(projectDir, localNodeTypes)) : null,
+            fs_1.default.existsSync(devToolsNodeTypes) ? toPosixPath(path_1.default.relative(projectDir, devToolsNodeTypes)) : null,
+        ].filter((entry) => Boolean(entry)),
+    };
+}
+function createHookCompilerOptions(projectPath) {
+    const projectDir = process.cwd();
+    const projectTsconfig = path_1.default.resolve(projectDir, projectPath);
+    return getHookCompilerOptions(projectDir, projectTsconfig);
+}
+function createHookTsConfig(projectPath) {
+    const projectDir = process.cwd();
+    const projectTsconfig = path_1.default.resolve(projectDir, projectPath);
+    const compilerOptions = getHookCompilerOptions(projectDir, projectTsconfig);
+    const tempRootDir = path_1.default.join(projectDir, '.tmp', 'redbox-dev-tools');
+    fs_1.default.mkdirSync(tempRootDir, { recursive: true });
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(tempRootDir, 'tsconfig-'));
+    const tempTsconfigPath = path_1.default.join(tempDir, 'tsconfig.json');
+    const tempConfig = {
+        extends: toPosixPath(path_1.default.relative(tempDir, projectTsconfig)),
+        compilerOptions: {
+            baseUrl: toPosixPath(path_1.default.relative(tempDir, projectDir)) || '.',
+            paths: compilerOptions.paths,
+            typeRoots: compilerOptions.typeRoots.map(entry => toPosixPath(path_1.default.relative(tempDir, path_1.default.resolve(projectDir, entry)))),
+        },
+    };
+    fs_1.default.writeFileSync(tempTsconfigPath, JSON.stringify(tempConfig, null, 2) + '\n');
+    return tempTsconfigPath;
+}
+function cleanupHookTsConfig(tempTsconfigPath) {
+    const tempDir = path_1.default.dirname(tempTsconfigPath);
+    fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,10 @@
+export interface RedboxPaths {
+    root: string;
+    coreTypes: string;
+    angular: string;
+}
+export declare function resolvePaths(options: {
+    root?: string;
+    coreTypesRoot?: string;
+    angularRoot?: string;
+}): RedboxPaths;

package/dist/utils/paths.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePaths = resolvePaths;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+function resolvePaths(options) {
+    if (!options.root) {
+        throw new Error('The --root option is required for this command.');
+    }
+    const root = path.resolve(options.root);
+    if (!fs.existsSync(root)) {
+        throw new Error(`The provided root directory does not exist: ${root}`);
+    }
+    const coreTypes = options.coreTypesRoot
+        ? path.resolve(options.coreTypesRoot)
+        : path.join(root, 'packages', 'redbox-core');
+    const angular = options.angularRoot ? path.resolve(options.angularRoot) : path.join(root, 'angular');
+    // Basic validation
+    if (!fs.existsSync(path.join(coreTypes, 'package.json'))) {
+        console.warn(`Warning: Could not find redbox-core at ${coreTypes}`);
+    }
+    return {
+        root,
+        coreTypes,
+        angular,
+    };
+}

package/index.js

@@ -0,0 +1,4 @@
+// Export the path to the shared tsconfig for easy reference
+module.exports = {
+  tsConfigPath: require.resolve('./config/tsconfig.base.json')
+};

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@researchdatabox/redbox-dev-tools",
+  "version": "0.0.1-beta.10173",
+  "description": "ReDBox customisation dev tools - shared configuration, generators, and migration tooling",
+  "type": "commonjs",
+  "main": "index.js",
+  "bin": {
+    "redbox-dev-tools": "./bin/cli.js",
+    "redbox-hook-mocha": "./bin/run-hook-mocha.js",
+    "redbox-hook-tsc": "./bin/run-hook-tsc.js"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "config/",
+    "templates/",
+    "skills/",
+    "index.js",
+    "runtime-resolver.js",
+    "runtime-resolver.d.ts",
+    "testing.js",
+    "testing.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "TS_NODE_PROJECT=test/tsconfig.json node -r ts-node/register ./node_modules/mocha/bin/_mocha --config .mocharc.js --exit test/**/*.test.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/redbox-mint/redbox-portal.git#v4.5.1"
+  },
+  "keywords": [
+    "Kit",
+    "Dev",
+    "Hook",
+    "ReDBox",
+    "TypeScript"
+  ],
+  "author": "Alejandro Bulgaris",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/redbox-mint/redbox-portal/issues"
+  },
+  "homepage": "https://github.com/redbox-mint/redbox-portal/tree/v4.5.1#readme",
+  "dependencies": {
+    "@researchdatabox/redbox-core": "0.0.1-beta.10173",
+    "@researchdatabox/sails-ng-common": "0.0.1-beta.10173",
+    "@tsconfig/node24": "24.0.4",
+    "@types/chai": "5.2.3",
+    "@types/lodash": "4.17.24",
+    "@types/mocha": "10.0.10",
+    "@types/node": "24.12.4",
+    "axios": "1.17.0",
+    "chai": "6.2.2",
+    "commander": "15.0.0",
+    "handlebars": "4.7.9",
+    "lodash": "4.18.1",
+    "mocha": "11.7.6",
+    "rxjs": "7.8.2",
+    "ts-node": "10.9.2",
+    "ts-morph": "28.0.0",
+    "typescript": "5.9.3",
+    "zod": "3.25.76"
+  },
+  "devDependencies": {
+    "@types/sinon": "21.0.1",
+    "sinon": "22.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@researchdatabox/redbox-core": {
+      "optional": false
+    }
+  },
+  "overrides": {
+    "diff": "8.0.4",
+    "mocha": {
+      "serialize-javascript": "7.0.5"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/runtime-resolver.d.ts

@@ -0,0 +1 @@
+export * from './dist/runtime-resolver';

package/runtime-resolver.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./dist/runtime-resolver.js');

package/skills/redbox-angular-apps/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: "Redbox Angular Apps"
+description: "ReDBox uses embedded Angular applications within EJS views instead of a single SPA. Each feature is often its own Angular project."
+---
+
+# Skill: Redbox Angular Apps
+
+## Context
+ReDBox uses embedded Angular applications within EJS views instead of a single SPA. Each feature is often its own Angular project.
+
+## Locations
+- Angular projects: `angular/projects/researchdatabox/<app-name>/`
+- Output assets: `assets/angular/<app-name>/browser/`
+- EJS views: `views/default/default/admin/<app-name>.ejs`
+
+## Generating Angular Apps
+Use the `redbox-dev-tools` CLI generator `generate_angular_app`:
+- `name`: App name as an argument (lowercase).
+- `--ejs-view <view>`: EJS view name.
+- `--auth <roles>`: Roles for page access.
+
+## Patterns
+- Apps are scaffolded using `@angular-devkit/build-angular:application`.
+- EJS views include the Angular component tag and the hashed JS/CSS bundles.
+- Use `CacheService.getNgAppFileHash(appName, type, prefix)` for hashed asset names.
+- Apps are usually served via `RenderViewController.render` with the view specified in `locals`.
+
+## angular.json
+New projects must be added to `angular.json` with appropriate `outputPath` and `baseHref`.
+Example `outputPath`: `../assets/angular/<name>`
+
+## Testing
+To run tests for a specific Angular app:
+- `ng test <app-name>`
+- `npm test -- <app-name>`
+
+### Root Execution
+If running inside a container as root (e.g. Docker), you must use the `--browsers=ChromeHeadlessNoSandbox` flag:
+`ng test --browsers=ChromeHeadlessNoSandbox <app-name>`
+
+### Convenience Script
+A convenience script is available at `support/unit-testing/angular/testDevAngular.sh` which handles the browser flags logic automatically.

package/skills/redbox-angular-services/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: "Redbox Angular Services"
+description: "Angular services in ReDBox typically extend `HttpClientService` to handle base URLs, configuration, and CSRF protection."
+---
+
+# Skill: Redbox Angular Services
+
+## Context
+Angular services in ReDBox typically extend `HttpClientService` to handle base URLs, configuration, and CSRF protection.
+
+## Location
+- Within an Angular project: `angular/projects/researchdatabox/<app-name>/src/app/`
+
+## Patterns
+- Extend `HttpClientService` from `@researchdatabox/portal-ng-common`.
+- Inject `HttpClient`, `APP_BASE_HREF`, `UtilityService`, and `ConfigService`.
+- Override `waitForInit()` and call `this.enableCsrfHeader()`.
+- Use `this.brandingAndPortalUrl` for building API URLs.
+- Use `this.httpContext` in request options to include the CSRF token.
+
+## Generating Angular Services
+Use the `redbox-dev-tools` CLI generator `generate_angular_service`:
+- `name`: Service name as an argument.
+- `--app <app>`: Target Angular app name.
+- `--methods <methods>`: Comma-separated list of methods to generate (e.g. `get,save`).
+
+## CSRF Handling
+- `this.enableCsrfHeader()` sets the `RB_HTTP_INTERCEPTOR_AUTH_CSRF` context variable.
+- For `FormData` uploads, you may need `RB_HTTP_INTERCEPTOR_SKIP_JSON_CONTENT_TYPE`.

package/skills/redbox-controllers/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: 'Redbox Controllers'
+description: 'ReDBox controllers live in `@researchdatabox/redbox-core` and are surfaced to Sails.js through generated shims.'
+---
+
+# Skill: Redbox Controllers
+
+## Context
+
+ReDBox controllers live in `@researchdatabox/redbox-core` and are surfaced to Sails.js through generated shims.
+
+## Locations
+
+- API controllers: `packages/redbox-core/src/controllers/`
+- Webservice controllers: `packages/redbox-core/src/controllers/webservice/`
+
+## Patterns
+
+- Extend `Controllers.Core.Controller`.
+- Implement `init()` for sails-dependent setup (avoid using `sails` in constructors).
+- Use `_exportedMethods` to define which methods are exposed.
+- Actions are usually `async index(req, res)`.
+- **Response Handling:** Use `this.sendResp(data, req, res)` instead of direct `res.json()` or `res.send()`. This ensures consistent response formatting.
+
+## Type Safety Guidance
+
+- Do not use `(object as any)`, `as any`, or other deliberate `any` casts to bypass TypeScript compilation errors. Fix the types, declare appropriate interfaces, or request assistance from the team.
+
+## Generating Controllers
+
+Use the `redbox-dev-tools` CLI generator `generate controller`:
+
+- `name`: Controller name (e.g., `MyRecord`) as an argument.
+- `--actions <list>`: Comma-separated actions (e.g., `index,get,save`).
+- `--webservice`: If it's a webservice controller.
+- `--routes <routes>`: Action-to-route mappings: `action:verb:path[:role1:role2],...` (e.g., `list:get:/api/items:Admin:Researcher`).
+- `--auth <roles>`: Default roles for auth rules (can be overridden per-route).
+
+## Adding Methods
+
+Use `redbox-dev-tools generate method` to add actions to an existing controller:
+
+- `--file <path>`: Path to the controller file.
+- `--method <name>`: Method name.
+- `--route <route>`: Route path (e.g., `/api/new-path`).
+- `--http <verb>`: HTTP verb (GET, POST, etc.).
+- `--auth <roles>`: Auth roles.
+
+## Index Updates
+
+When adding a controller, you must update `packages/redbox-core/src/controllers/index.ts`:
+
+- Import the controller module.
+- Add to `ControllerExports` (or `WebserviceControllerExports`) with a lazy getter.
+- Add to `ControllerNames` (or `WebserviceControllerNames`) array.
+
+## Route Configuration
+
+Routes are defined in `packages/redbox-core/src/config/routes.config.ts`.
+Pattern: `'get /api/my-path': { controller: 'MyController', action: 'index' }`
+
+## Auth Rules
+
+Auth rules are defined in `packages/redbox-core/src/config/auth.config.ts`.
+Pattern: `{ path: '/api/my-path', role: 'admin', can_read: true }`

package/skills/redbox-feature-design-planner/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: redbox-feature-design-planner
+description: Create detailed feature designs, implementation plans, and task lists for ReDBox/Redbox features that use Waterline models, services, webservice (REST) controllers, ajax controllers, embedded Angular apps, views, and navigation config. Use when asked to design/plan a feature or produce a task list for this stack, especially when explicit sections, non-SPA Angular patterns, and interleaved tests are required.
+---
+
+# Redbox Feature Design Planner
+
+## Overview
+
+Produce a detailed design, implementation plan, and task list for ReDBox features, organized by the required architecture sections and validated for internal consistency.
+
+## Required Nuances (Must Apply)
+
+- **Angular apps are embedded, not SPAs.** Do not design Angular routing. Pages are routed by Sails + EJS views, and Angular apps mount inside those views.
+- **Controllers/services/models live in `@researchdatabox/redbox-core` and are surfaced via shims.** Respect loader/shim behavior and registration conventions.
+- **Controllers use `init()` + `_exportedMethods` and respond via `sendResp`.** Avoid `sails` usage in constructors.
+- **Auth and routes are explicit config.** Route entries live in `packages/redbox-core/src/config/routes.config.ts` and auth rules in `packages/redbox-core/src/config/auth.config.ts`.
+- **Hook overrides are first-class.** If the feature is delivered via a hook, ensure `package.json` `sails` capabilities match exports and that overrides use the same names as core components.
+- **Use Hook Kit CLI generators when possible.** Prefer `redbox-dev-tools` generators for scaffolding controllers, services, models, Angular apps/services, and form fields.
+
+## Workflow
+
+1. Gather scope and assumptions
+   - Extract: feature goal, primary users, key workflows, data entities, and required UI surfaces.
+   - Ask up to 3 clarifying questions only if required to avoid blocking.
+   - If information is missing, state explicit assumptions before the design.
+
+2. Consult authoritative references (lightweight)
+   - Prefer wiki docs under `support/wiki/` (Architecture, Controllers, Services, Loader, Hook Kit, Testing, Hook customization).
+   - Use relevant skills: Redbox Services, Redbox Controllers, Redbox Angular Apps, Redbox Angular Services, Redbox Hook Development, Redbox Testing.
+
+3. Produce the design in required sections
+   - Use the exact section order in the Output Template below.
+   - For each section, specify: purpose, new/changed files, new/changed APIs, validation rules, permissions, and edge cases.
+   - Keep names consistent across sections (models, services, controllers, Angular modules, routes).
+
+4. Run consistency analysis
+   - Validate the design end-to-end: models -> services -> controllers -> UI -> navigation.
+   - Call out mismatches, missing artifacts, or unclear ownership.
+   - List open questions and risks separately from assumptions.
+
+5. Produce the implementation plan
+   - Provide ordered steps with file-level granularity and rationale.
+   - Reference relevant skills explicitly for each step.
+
+6. Produce the task list with tests interleaved
+   - Match the same section order as the design.
+   - Interleave unit tests after each task, not at the end.
+   - Add integration test gates exactly at the required points.
+   - Explicitly mention which skills to use for each task.
+   - Identify missing skills required to complete tasks.
+
+## Output Template
+
+Use this structure and headings verbatim. Keep content concise but explicit.
+
+# Design
+
+## 1. Data Model (Waterline Models)
+
+- Purpose and scope
+- New/changed models and attributes
+- Relationships and indexes
+- Validation, lifecycle hooks, and defaults
+- Access control considerations
+- File locations and naming (core-types vs hook, and shim implications)
+- Hook delivery requirements (capabilities + `registerRedboxModels()` if applicable)
+
+## 2. Services Layer (Business Logic)
+
+- Service responsibilities
+- Public methods, inputs/outputs, and errors
+- Transaction boundaries and side effects
+- Dependencies on models, configs, or external services
+- File locations and naming
+- Service conventions (extend `Services.Core.Service`, `_exportedMethods`, `bootstrap()`, RxJS, model globals)
+- Export/update requirements (ServiceExports index and hook overrides)
+
+## 3. Webservice Controllers (REST API)
+
+- Endpoint list (method + path)
+- Request/response shapes and status codes
+- Authn/authz and policy usage
+- Error handling and validation (use `sendResp`)
+- File locations and naming
+- Controller conventions (extend `Controllers.Core.Controller`, `init()`, `_exportedMethods`)
+- Export/update requirements (ControllerExports index, routes, auth config)
+
+## 4. Ajax Controllers (Controllers)
+
+- Endpoint list (method + path or action)
+- Request/response shapes
+- Authn/authz and policy usage
+- Error handling and validation (use `sendResp`)
+- File locations and naming
+- Controller conventions (extend `Controllers.Core.Controller`, `init()`, `_exportedMethods`)
+- Export/update requirements (ControllerExports index, routes, auth config)
+
+## 5. Angular App(s)
+
+- Apps/modules to add or modify (embedded apps only)
+- Routes: **Do not use Angular Router**; specify Sails/EJS view routing instead
+- Components and services
+- Data flow to/from APIs
+- State management and error handling
+- File locations and naming (Angular workspace + EJS view + assets output)
+- EJS view wiring (component tag + hashed asset includes using `CacheService.getNgAppFileHash`)
+- Render path (typically `RenderViewController.render` with `locals.view`)
+
+## 6. Additional Views
+
+- View templates to add/modify
+- Server-side data needed to render
+- Where view is wired in (e.g., RenderViewController.render)
+- Hook asset/view copy behavior if applicable
+
+## 7. Navigation Configuration
+
+- Menu/route entries to add/modify
+- Role/permission gating
+- File locations and naming
+
+# Consistency Analysis
+
+- Cross-checks across all layers
+- Missing pieces or conflicts
+- Assumptions
+- Open questions
+- Risks
+
+# Implementation Plan
+
+- Step-by-step plan with file-level detail and skill references
+
+# Task List (With Tests and Skill Usage)
+
+- Sectioned tasks following the same order as the design
+- Each task includes a matching unit test task
+- Before any integration test run task, add a code review task using the redbox-feature-implementation-review skill with instructions:
+  - If issues are found: write the result to issues.json in the project root
+  - If issues are found: add two tasks immediately after the current task:
+    - Fix all issues listed in issues.json and delete issues.json when done
+    - Re-run the code review using redbox-feature-implementation-review
+- Integration test gates:
+  - After Data Model + Services: create Mocha integration tests and run them; do not continue until passing
+  - After Controllers: create Bruno tests and run them; do not continue until passing
+  - Final: run both integration suites again
+- Each task explicitly names required skills
+- End with a "Skill Gaps" subsection if any skills are missing
+
+## Skill Guidance
+
+- Reference existing skills by name when writing tasks.
+- Prefer these skills when relevant: Redbox Services, Redbox Controllers, Redbox Angular Apps, Redbox Angular Services, Redbox Hook Development, Redbox Form Config, Redbox Testing, Web Interface Verification.
+- Use Hook Kit CLI generators when they match the task (controllers, services, models, Angular apps/services, form fields).
+- If a task does not map cleanly to an existing skill, call it out under "Skill Gaps" and suggest a new skill name and scope.
+
+## Repo Context Reminders
+
+- Prefer wiki documentation under `support/wiki/` when referencing ReDBox architecture or conventions.
+- Key docs: `Controllers-Architecture`, `Services-Architecture`, `Redbox-Loader`, `redbox-dev-tools`, `ReDBox-Automated-Tests`, `Using-a-Sails-Hook-to-customise-ReDBox`.
+- Use the Coding Standards wiki for naming conventions and TypeScript rules.
+- Use Redbox Testing skill guidance for Mocha and Bruno testing workflows.
+
+## Notes on Specificity
+
+- Be explicit enough that a smaller model can execute the plan without inference.
+- Include concrete file path examples when possible.
+- Avoid vague statements like "update the service"; name the service, method, and expected behavior.