@pikaa-ai/pikaa 0.2.5 → 0.3.1

package/skills/matlab/references/matrices-arrays.md

@@ -0,0 +1,228 @@
+# Arrays, Indexing, Data Types, and Performance
+
+This reference targets MATLAB R2026a. Verify GNU Octave behavior separately.
+
+## Array model
+
+MATLAB is 1-based and column-major. Most numeric literals are `double`.
+Orientation and trailing singleton dimensions matter.
+
+```matlab
+row = 1:5;                 % 1-by-5
+column = (1:5).';          % 5-by-1, nonconjugate transpose
+A = reshape(1:12, 3, 4);   % values fill down columns
+
+sameShape = zeros(size(A), "like", A);
+singleData = zeros(100, 1, "single");
+logicalMask = false(size(A));
+```
+
+Use `.'` for a plain transpose and `'` for a conjugate transpose. Use
+`size(A,dim)`, `numel`, and `ndims`; avoid `length` when a specific dimension
+is intended.
+
+### Core storage choices
+
+| Type | Use | Caution |
+|---|---|---|
+| dense numeric/logical array | homogeneous computation | implicit conversion and memory |
+| sparse numeric/logical array | low-density 2-D matrices | not every operation preserves sparsity |
+| string array | text with missing values | differs from character arrays |
+| categorical | finite labels and ordering | undefined category is missing |
+| cell array | heterogeneous containers | `{}` versus `()` semantics |
+| structure | named heterogeneous fields | structure arrays complicate shape |
+| table | named, equal-height variables | `()` versus `{}` versus dot indexing |
+| timetable | table with row times | time zone, sorting, duplicates, alignment |
+| datetime/duration | time points/elapsed time | time zones and calendar duration differ |
+
+Choose integer classes for storage or exact integer semantics, not as a drop-in
+for floating computation. Integer overflow and mixed-class operations need
+explicit tests. Preserve units in names or metadata.
+
+## Indexing
+
+```matlab
+value = A(2, 3);       % row 2, column 3
+linear = A(5);         % column-major linear index
+row = A(2, :);
+lastRows = A(max(1,end-2):end, :);
+positive = A(A > 0);
+A(A < 0) = 0;
+
+[r, c] = ind2sub(size(A), linearIndex);
+linearIndex = sub2ind(size(A), r, c);
+```
+
+Prefer logical indexing for selection and `find` only when numeric indices are
+needed. Verify mask shape. Deleting with `A(index)=[]` changes shape and can be
+ambiguous for multidimensional arrays.
+
+### Cell, structure, and table indexing
+
+```matlab
+C = {42, "sample"; [1 2], datetime("today")};
+cellContainer = C(1, :);  % still a cell array
+cellContent = C{1, 1};    % contained value
+
+S.SampleID = "S01";
+name = S.("SampleID");
+
+tableSlice = T(1:10, ["Time" "Value"]); % table
+numericValues = T{:, "Value"};          % underlying content
+oneVariable = T.Value;                  % variable content
+```
+
+Curly extraction from a table succeeds only when selected variable contents
+can concatenate. Preserve table form when variable names and metadata matter.
+
+## Operators and implicit expansion
+
+| Operation | Matrix | Element-wise |
+|---|---|---|
+| multiply | `A*B` | `A.*B` |
+| divide | `A/B`, `A\B` | `A./B`, `A.\B` |
+| power | `A^n` | `A.^n` |
+
+Addition, subtraction, comparisons, and many element-wise functions use
+compatible-size implicit expansion. Since R2016b, a column and row can create
+an outer result:
+
+```matlab
+x = (1:3).';
+y = 10:10:40;
+outerSum = x + y;   % 3-by-4
+```
+
+Before relying on expansion, assert intended orientation:
+
+```matlab
+assert(iscolumn(x));
+assert(isrow(y));
+```
+
+Do not use `repmat` solely to emulate supported implicit expansion, but use it
+when an explicitly materialized tiled array is actually needed.
+
+## Missing and nonfinite values
+
+Standard missing values are type-specific:
+
+- `NaN`: `double`, `single`, `duration`, `calendarDuration`
+- `NaT`: `datetime`
+- `<missing>`: `string`
+- `<undefined>`: `categorical`
+- `''` inside a cell array of character vectors
+
+Integer and logical arrays have no standard missing value. A sentinel such as
+`-99` is a data contract, not a MATLAB default.
+
+```matlab
+missingMask = ismissing(T);
+anyMissing = anymissing(T);
+clean = rmmissing(T);
+filled = fillmissing(T, "linear", DataVariables="Value");
+```
+
+Define whether `Inf` is valid separately; it is not a standard missing
+floating-point value. `isfinite` distinguishes finite values. `ismissing`
+ignores timetable row times, so validate row times explicitly.
+
+## Tables and timetables
+
+Every table variable has the same row count but can have a different type and
+width. Timetables add row times.
+
+```matlab
+T = table(sampleID, group, value, ...
+    VariableNames=["SampleID" "Group" "Value"]);
+
+TT = timetable(time, value, quality, ...
+    VariableNames=["Value" "Quality"]);
+TT = sortrows(TT);
+hourly = retime(TT, "hourly", "mean");
+aligned = synchronize(TT1, TT2, "intersection");
+```
+
+Before time alignment:
+
+1. normalize or record time zones;
+2. define duplicate-time policy;
+3. sort row times;
+4. choose union/intersection and interpolation/aggregation deliberately;
+5. record daylight-saving and calendar assumptions.
+
+Direct calculations on tables/timetables are supported for compatible
+variables, but mixed nonnumeric variables can invalidate an operation.
+Selecting numeric variables first is often clearer:
+
+```matlab
+numericT = T(:, vartype("numeric"));
+```
+
+## Concatenation and reshaping
+
+```matlab
+wide = [A B];
+tall = [A; B];
+flat = A(:);
+B = reshape(A, [], 4);
+C = permute(X, [2 1 3]);
+```
+
+Concatenated dimensions and classes must be compatible. `squeeze` can remove
+different dimensions depending on input shape; avoid it in APIs whose output
+rank must be stable.
+
+## Performance without folklore
+
+1. Write the clearest correct array code.
+2. Use representative data and `timeit`; use the profiler for call-level
+   diagnosis.
+3. Preallocate when a loop's output shape is known.
+4. Vectorize operations that map naturally to array kernels.
+5. Keep a loop when vectorization creates large temporaries or obscures logic.
+6. Preserve sparsity and data class where appropriate.
+7. Benchmark each supported release/platform; R2026a includes implementation
+   speedups that can change old trade-offs.
+
+```matlab
+y = zeros(size(x), "like", x);
+for k = 1:numel(x)
+    y(k) = localTransform(x(k));
+end
+```
+
+Avoid growing arrays in a loop. However, do not preallocate the wrong class or
+shape. `zeros(size(x),"like",x)` is usually safer than an unqualified `zeros`.
+
+Parallel arrays, GPU arrays, tall arrays, `parfor`, and distributed arrays
+require specific products and supported functions. They also change ordering,
+reduction, RNG, and tolerance concerns. Do not suggest them merely because a
+loop exists.
+
+## Numerical review checklist
+
+- [ ] Shapes and orientation are asserted where expansion matters.
+- [ ] Matrix versus element-wise operators are intentional.
+- [ ] Conjugation behavior is intentional.
+- [ ] Indexing preserves expected rank and container type.
+- [ ] Missing, nonfinite, and sentinel policies are explicit.
+- [ ] Table variable names/types and timetable time zones are preserved.
+- [ ] Integer overflow and mixed-class conversion are tested.
+- [ ] Sparse inputs remain sparse where required.
+- [ ] Preallocation and vectorization are measured, not assumed.
+- [ ] Memory estimates include temporaries and expanded outputs.
+
+## Sources (verified 2026-07-23)
+
+- [Array Indexing](https://www.mathworks.com/help/matlab/math/array-indexing.html)
+- [Compatible Array Sizes for Basic Operations](https://www.mathworks.com/help/matlab/matlab_prog/compatible-array-sizes-for-basic-operations.html)
+- [MATLAB Data Types](https://www.mathworks.com/help/matlab/data-types.html)
+- [Tables](https://www.mathworks.com/help/matlab/tables.html)
+- [Timetables](https://www.mathworks.com/help/matlab/timetables.html)
+- [`ismissing`](https://www.mathworks.com/help/matlab/ref/ismissing.html)
+- [Missing Data in MATLAB](https://www.mathworks.com/help/matlab/data_analysis/missing-data-in-matlab.html)
+- [Vectorization](https://www.mathworks.com/help/matlab/matlab_prog/vectorization.html)
+- [Preallocation](https://www.mathworks.com/help/matlab/matlab_prog/preallocating-arrays.html)
+- [`timeit`](https://www.mathworks.com/help/matlab/ref/timeit.html)
+- [Profile MATLAB Code](https://www.mathworks.com/help/matlab/matlab_prog/profiling-for-improving-performance.html)

package/skills/matlab/references/octave-compatibility.md

@@ -0,0 +1,212 @@
+# GNU Octave 11.3.0 Compatibility
+
+GNU Octave 11.3.0 is the current stable release as of 2026-07-23 (released
+2026-06-01). It is free software under GPLv3+. MATLAB R2026a is proprietary.
+Do not describe Octave as MATLAB, a licensed toolbox substitute, or a
+drop-in guarantee.
+
+## Compatibility policy
+
+Use three labels:
+
+- **portable subset**: tested in both exact target versions;
+- **MATLAB-only**: depends on MATLAB syntax, objects, projects, products, or
+  deployment;
+- **Octave-only**: uses Octave syntax, packages, BIST, or runtime behavior.
+
+Source resemblance is not enough. Compare outputs with scientific tolerances,
+edge cases, warnings, graphics, performance, and file round trips.
+
+## Current release changes
+
+Octave 11 introduced improved `classdef` support, broadcasting for sparse,
+diagonal, and permutation matrices, more MATLAB-compatible `nanflag`/`vecdim`
+behavior, and many function/performance changes. It is still not fully
+compatible. NEWS-11 also records behavior changes that can break older Octave
+code, including stricter accepted types for several statistics functions.
+
+Read both the current manual and NEWS before migrating to 11.3.0. The online
+`latest` manual reviewed on this date identifies its generated content as
+11.1.0 while the project download/news page identifies 11.3.0 as current;
+consult NEWS-11 for the maintenance-release delta.
+
+## Command-line differences
+
+Reviewed Octave argv usually includes:
+
+```text
+["octave", "--no-init-all", "--no-history", "--quiet", "--no-gui", "main.m"]
+```
+
+The bundled planner returns argv but never executes it.
+
+Current manual behavior:
+
+- `--eval`/`-e` evaluates code and exits unless `--persist` is set;
+- a filename executes and exits;
+- `--no-gui` selects CLI;
+- `--no-window-system` disables graphics/window-system use;
+- `--no-init-all`/`--norc` skips system and user initialization;
+- `--path` adds a function path;
+- `--quiet` suppresses greeting; `--no-history` avoids history writes.
+
+Octave startup can execute site/version files, user configuration,
+project-local `.octaverc`, and MATLAB-compatible `startup.m`. Skipping all
+startup files can improve reproducibility but can also remove expected package
+or path setup. Review the plan.
+
+MATLAB uses `-batch`, has different startup processing, and has no Octave
+`--no-init-all` option. Never pass the same flags to both.
+
+## Syntax: portable versus Octave-only
+
+Prefer:
+
+- `%` comments;
+- `...` continuation;
+- `end` block terminators;
+- explicit `x = x + 1`;
+- intermediate variables before indexing a function result;
+- short-circuit `&&`/`||` for scalar conditions;
+- ordinary `.m` functions with matching filenames.
+
+Avoid these Octave-only extensions in portable code:
+
+- `#` comments;
+- `endif`, `endfor`, `endfunction`;
+- `++`, `--`, `+=`, and related compound assignment;
+- `do ... until`;
+- indexing directly into an expression result;
+- backslash line continuation;
+- Octave package/BIST directives in MATLAB production files unless isolated.
+
+Both support implicit expansion/broadcasting in many modern cases, but special
+classes and edge cases differ. Octave 11 expanded broadcasting for special
+matrix types. Test orientation, sparse output, empty dimensions, and mixed
+classes in both.
+
+## MATLAB features with no assumed Octave equivalent
+
+The current Octave manual does not establish drop-in equivalents for:
+
+- MATLAB `arguments` blocks and all validators/name-value semantics;
+- `table`/`timetable` workflows and their R2026a JSON conversions;
+- MATLAB Projects, dependency analyzer, Project Upgrade, or project-aware
+  `runtests`;
+- `matlab.unittest`, MATLAB Test, Code Quality Dashboard;
+- live scripts `.mlx`, App Designer `.mlapp`, `.fig` object compatibility;
+- Simulink and MathWorks toolbox APIs;
+- MATLAB Engine API for Python, MATLAB Compiler/Runtime, MATLAB Coder, or
+  MathWorks deployment products;
+- full MATLAB `classdef`, events/listeners, serialization, and metaclass
+  behavior.
+
+Use feature detection and separate adapters only after testing. Do not silently
+replace a missing MATLAB toolbox function with a similarly named Octave
+package function.
+
+## Packages versus toolboxes
+
+Octave packages are distributed separately from core Octave. MATLAB toolboxes
+are separately licensed MathWorks products. APIs, algorithms, defaults,
+validation, object models, and release schedules differ.
+
+Never run `pkg install`, load an untrusted package, or alter `.octaverc`
+automatically. Package installation can fetch/build/execute code. Record exact
+package name/version/source/checksum and obtain approval.
+
+`pkg load` mutates the function path and can shadow core or project functions.
+Test `which`/resolution only in a trusted approved runtime.
+
+## Tests
+
+Octave's built-in self-test system scans `%!` blocks and uses `test`. It is not
+`matlab.unittest`.
+
+```matlab
+%!test
+%! observed = hypot(3, 4);
+%! assert(observed, 5, 1e-12);
+```
+
+Portable production functions and runtime-specific test harnesses should be
+separate when test syntax differs. The nonexecuting planner can prepare an
+Octave BIST argv, but an approved runtime is required to run it.
+
+## MAT and HDF5 compatibility
+
+Octave 11 supports writing MATLAB v4, v6, and v7 binary formats. It **does not
+implement saving MATLAB v7.3**.
+
+Octave can save its own HDF5 representation when built with HDF5. Its `load
+-hdf5` has limited ability to read MATLAB v7.3, mainly for supported numeric
+content; many types are unsupported. An Octave HDF5 file is not automatically
+a MATLAB v7.3 file.
+
+Octave's current manual states that `classdef` objects are saved as structures
+in supporting formats and are not restored as `classdef` objects. This differs
+substantially from MATLAB object serialization.
+
+Never load untrusted MAT/HDF5 files in either runtime. Use the bundled bounded
+technical inventory first, then escalate object/opaque/function/external-link
+content.
+
+For portable simple data, use MATLAB v7 only after testing classes, shapes,
+text, sparse/complex values, and metadata. Prefer schema-documented
+language-neutral formats where feasible.
+
+## Graphics
+
+Basic calls such as `plot`, labels, legends, images, surfaces, and `print` are
+similar, but renderers, fonts, properties, layout, transparency, callbacks,
+and export formats differ.
+
+Do not assume Octave implements R2026a `exportgraphics`, SVG/HTML web canvas,
+`tiledlayout`, UI objects, or property behavior. Build a small compatibility
+test and compare exported dimensions, font embedding, vector/raster content,
+colors, and clipping.
+
+Octave 11 NEWS documents graphics compatibility changes such as colorbar and
+event-field behavior. Review NEWS for each update.
+
+## Numerical differences
+
+Even when both runtimes call similarly named LAPACK/BLAS-backed functions,
+results can differ because of:
+
+- linked libraries, versions, threads, and architecture;
+- solver implementation/default/tolerance changes;
+- sparse ordering and pivot choices;
+- random generator algorithms and streams;
+- toolbox/package algorithms;
+- floating reduction order;
+- unsupported or converted classes.
+
+Compare residuals, invariants, objective/feasibility, and domain observables.
+Do not demand identical eigenvector signs, cluster bases, or bitwise
+floating-point output without a justified contract.
+
+## Portability checklist
+
+- [ ] Exact MATLAB and Octave versions recorded.
+- [ ] Core versus toolbox/package requirements separated.
+- [ ] Only portable syntax used in shared source.
+- [ ] Shapes, missing values, strings, and implicit expansion tested.
+- [ ] RNG algorithm/seed behavior tested separately.
+- [ ] Numerical tolerances justified.
+- [ ] MAT/HDF5 round trips cover every used class.
+- [ ] Graphics compared from exported files.
+- [ ] Runtime-specific tests and deployment kept separate.
+- [ ] No package installation or code execution occurred implicitly.
+
+## Sources (verified 2026-07-23)
+
+- [GNU Octave home/current release](https://octave.org/)
+- [GNU Octave 11 release notes](https://octave.org/NEWS-11.html)
+- [GNU Octave current manual](https://docs.octave.org/latest/)
+- [Command-Line Options](https://docs.octave.org/latest/Command-Line-Options.html)
+- [Startup Files](https://docs.octave.org/latest/Startup-Files.html)
+- [Simple File I/O and MAT v7.3 limitation](https://docs.octave.org/latest/Simple-File-I_002fO.html)
+- [`classdef` compatibility status](https://docs.octave.org/latest/classdef-Classes.html)
+- [Test Functions](https://docs.octave.org/latest/Test-Functions.html)
+- [GNU GPL](https://octave.org/license.html)

package/skills/matlab/references/programming.md

@@ -0,0 +1,225 @@
+# Programming, Projects, Analysis, and Tests
+
+This reference targets MATLAB R2026a. Base MATLAB, separately licensed
+products, and GNU Octave must not be conflated.
+
+## Choose the right code artifact
+
+| Artifact | Workspace | Best use | Main risk |
+|---|---|---|---|
+| script `.m` | caller/base workspace | small reviewed orchestration | hidden inputs, leaked variables, path/state dependence |
+| function `.m` | local workspace | reusable computation and automation | implicit conversions or undocumented side effects |
+| live script `.mlx` | script-like interactive workspace | narrative exploration and teaching | opaque archive, embedded output, weak text review |
+| class `.m` | object state and methods | durable abstractions | constructors, listeners, serialization callbacks |
+| MEX | native process code | approved performance/interface work | arbitrary native execution |
+
+Prefer a function with explicit inputs, outputs, and an `arguments` block.
+Keep a top-level script thin. Export reviewed live code to plain `.m` before
+static inspection. Never open or run an untrusted project, live script, app,
+class, MEX file, or package.
+
+Scripts share the base workspace and leave variables there. Functions,
+including local functions, have private workspaces. Since R2024a, local
+functions in scripts can appear anywhere in the file except inside conditional
+contexts. The main function should match its filename.
+
+```matlab
+function summary = summarizeSignal(signal, options)
+%SUMMARIZESIGNAL Return deterministic summary statistics.
+arguments
+    signal (:,1) double {mustBeFinite}
+    options.Center (1,1) logical = true
+end
+
+if options.Center
+    signal = signal - mean(signal);
+end
+summary = struct( ...
+    "Count", numel(signal), ...
+    "Mean", mean(signal), ...
+    "StandardDeviation", std(signal));
+end
+```
+
+### Argument validation details
+
+- A size declaration such as `(:,1)` permits a column of any height.
+- A class declaration can convert compatible input. Do not mistake conversion
+  for validation.
+- Validators such as `mustBeFinite` check values without changing them.
+- A default makes an argument optional. Required positional inputs precede
+  optional inputs.
+- Name-value inputs use a structure name in the signature and dotted fields in
+  the block.
+- Code generation support is a MATLAB Coder capability with additional
+  restrictions and a separate license; an `arguments` block alone does not
+  make code generation available.
+
+## Workspace and path hygiene
+
+1. Derive files from a confirmed project root, not the user's incidental
+   current folder.
+2. Use `fullfile`; never construct paths by concatenating separators.
+3. Add the narrowest reviewed directory. Avoid broad `genpath` because it can
+   expose hidden, generated, test, private, or malicious files.
+4. Do not silently mutate `path`, `userpath`, preferences, startup files, or
+   Java/native search paths.
+5. Avoid `global`, `persistent` cache state without invalidation, and broad
+   clearing. `clear all` can clear loaded functions and disrupt debugging.
+6. Use `onCleanup` for resources such as files and temporary state.
+7. Pass loaded data through a structure (`S = load(...)`) rather than injecting
+   names into a function or base workspace—but only after the MAT file is
+   trusted.
+
+MATLAB runs `startup.m` when it is found on the search path and `finish.m` on
+normal exit. Projects can add paths and run startup/shutdown actions. Review all
+of these before execution.
+
+## Dynamic and external execution surfaces
+
+Escalate any use of:
+
+- `eval`, `evalin`, `assignin`, `str2func`, text-derived `feval`, dynamic
+  property or callback names;
+- shell entry points (`system`, `unix`, `dos`, `!`);
+- Java class paths/methods, .NET assemblies, Python (`py.*`, `pyrun`,
+  `pyrunfile`), MEX, C/C++ libraries, and generated code;
+- timers, UI callbacks, listeners, project tasks, build tasks, package startup,
+  and test fixtures with external effects;
+- object loading (`loadobj`, `matlab.mixin.CustomElementSerialization`) and
+  System object load hooks.
+
+Function handles are safer than text dispatch only when the handle itself comes
+from trusted code. Never pass untrusted text into a dispatch mechanism. Static
+scanning is triage, not proof of absence.
+
+## MATLAB Projects
+
+A project can track files, control the path, declare references and packages,
+run startup/shutdown tasks, integrate source control, and analyze dependencies.
+Use project APIs only after reviewing project metadata and tasks.
+
+Recommended project record:
+
+- project name and root;
+- MATLAB release and architecture;
+- entry points and test roots;
+- required and optional MathWorks products, each with license status
+  `unknown`, `confirmed`, or `unavailable`;
+- external system dependencies and generated artifacts;
+- startup/shutdown actions and path changes;
+- RNG/tolerance/data-schema policy.
+
+Dependency Analyzer and `matlab.codetools.requiredFilesAndProducts` use static
+analysis. Dynamic dispatch, overloaded methods, callbacks, generated names, and
+conditional paths can cause misses or false positives. Their product lists do
+not prove that a license can be checked out.
+
+## Code Analyzer and compatibility checks
+
+Use these only on trusted text:
+
+- `codeIssues(path)` returns a structured Code Analyzer result and supports
+  programmatic fixes for eligible issues.
+- `checkcode(path)` remains useful for text-oriented or legacy automation.
+- `codeCompatibilityReport(path)` finds potential issues after a release
+  upgrade.
+- Project Upgrade can check and apply some release migrations and produce a
+  report.
+
+Do not auto-apply fixes across a scientific codebase without tests. Analyzer
+silence does not establish numerical correctness, security, toolbox
+availability, or Octave compatibility.
+
+Migration sequence:
+
+1. Freeze representative outputs and tolerance rationale in the old release.
+2. Record release, products, compilers, BLAS/threading context, RNG algorithm
+   and seed, and external data schema.
+3. Run static compatibility and dependency analysis.
+4. Read every relevant product's release notes and bug reports.
+5. Migrate shared libraries before applications.
+6. Run unit, integration, numerical-equivalence, graphics, and performance
+   checks.
+7. Investigate differences rather than automatically widening tolerances.
+
+R2026a-specific checks include changed/removed APIs in release notes, new JSON
+table/timetable I/O, Python 3.13 support, string-array Python conversion,
+interactive HTML graphics export, and platform/compiler support. R2026a no
+longer ships new MATLAB releases for Intel Macs.
+
+## Unit testing
+
+Base MATLAB includes script-, function-, and class-based `matlab.unittest`
+testing. Keep tests deterministic and independent of order.
+
+```matlab
+classdef TestSummarizeSignal < matlab.unittest.TestCase
+    methods (Test)
+        function centersFiniteColumn(testCase)
+            actual = summarizeSignal([1; 2; 3]);
+            testCase.verifyEqual(actual.Count, 3);
+            testCase.verifyEqual(actual.Mean, 0, AbsTol=1e-14);
+        end
+
+        function rejectsNonfiniteInput(testCase)
+            testCase.verifyError( ...
+                @() summarizeSignal([1; NaN]), ...
+                "MATLAB:validators:mustBeFinite");
+        end
+    end
+end
+```
+
+Use domain-derived `AbsTol` and `RelTol`; exact checks remain appropriate for
+integers, strings, dimensions, and invariants. Isolate file output in temporary
+folders and refuse network, interactive dialogs, or real credentials in unit
+tests.
+
+Product boundaries:
+
+- `runtests`, `testsuite`, `matlab.unittest.TestCase`, and ordinary framework
+  plugins are base MATLAB.
+- Parallel test execution requires Parallel Computing Toolbox.
+- Dependency-based test selection, MATLAB Test Manager, Code Quality Dashboard,
+  advanced coverage, generated tests, and equivalence workflows can require
+  MATLAB Test.
+- Requirements traceability can require Requirements Toolbox; generated-code
+  workflows can require MATLAB Coder, MATLAB Compiler SDK, Embedded Coder, or
+  other named products.
+
+In R2026a, `runtests` automatically opens a project for tests belonging to a
+project that is not already open and closes it afterward. This may execute
+reviewed project startup and shutdown actions; it is not safe for untrusted
+projects.
+
+## Review checklist
+
+- [ ] Main function and filename agree.
+- [ ] Inputs, shapes, classes, units, missingness, and outputs are documented.
+- [ ] No hidden base-workspace dependency.
+- [ ] Dynamic/external execution surfaces are absent or explicitly approved.
+- [ ] Paths are project-local and narrow.
+- [ ] Resources close on both success and failure.
+- [ ] Errors have stable identifiers where tests rely on them.
+- [ ] Tests cover edge shapes, empty values, missing values, nonfinite values,
+      numerical tolerances, and failure behavior.
+- [ ] Required products are declared separately from confirmed license status.
+- [ ] Migration evidence includes release notes and representative baselines.
+
+## Sources (verified 2026-07-23)
+
+- [Scripts vs. Functions](https://www.mathworks.com/help/matlab/matlab_prog/scripts-and-functions.html)
+- [Create Scripts](https://www.mathworks.com/help/matlab/matlab_prog/create-scripts.html)
+- [`arguments`](https://www.mathworks.com/help/matlab/ref/arguments.html)
+- [Local Functions](https://www.mathworks.com/help/matlab/matlab_prog/local-functions.html)
+- [MATLAB Projects](https://www.mathworks.com/help/matlab/projects.html)
+- [Analyze Project Dependencies](https://www.mathworks.com/help/matlab/matlab_prog/analyze-project-dependencies.html)
+- [`requiredFilesAndProducts`](https://www.mathworks.com/help/matlab/ref/matlab.codetools.requiredfilesandproducts.html)
+- [MATLAB Code Analyzer Report](https://www.mathworks.com/help/matlab/matlab_prog/matlab-code-analyzer-report.html)
+- [`codeCompatibilityReport`](https://www.mathworks.com/help/matlab/ref/codecompatibilityreport.html)
+- [Project Upgrade](https://www.mathworks.com/help/matlab/matlab_prog/upgrade-projects.html)
+- [Run Unit Tests](https://www.mathworks.com/help/matlab/run-unit-tests.html)
+- [`runtests` R2026a history](https://www.mathworks.com/help/matlab/ref/runtests.html)
+- [MATLAB Test product boundary](https://www.mathworks.com/products/matlab-test.html)
+- [MATLAB R2026a release notes](https://www.mathworks.com/help/matlab/release-notes.html)