@ketecode/loom 0.0.0-stage → 0.1.0

package/rules/csharp.md

@@ -0,0 +1,25 @@
+---
+name: csharp
+description: Always-on rules for C# and .NET code, covering nullable reference types, async and await, disposal, exceptions, data access safety, and build and test checks.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.cs"
+  kete-loom/owner: "Kete-org"
+---
+
+- Keep nullable reference types enabled and fix nullable warnings; never silence them with `!` unless the value is proven non-null.
+- Never block on async code with `.Result`, `.Wait()` or `.GetAwaiter().GetResult()`; use `await` all the way up.
+- Never write `async void` except for event handlers. Return `Task` or `ValueTask`.
+- Accept a `CancellationToken` in async APIs that do I/O and pass it to every call that takes one.
+- Dispose every `IDisposable` with `using` or `await using`; never leave a stream, connection or reader open.
+- Do not create a new `HttpClient` per request; use `IHttpClientFactory` or a shared instance.
+- Throw specific exceptions and rethrow with `throw;`, never `throw ex;`, which loses the stack trace.
+- Never build SQL by string concatenation or interpolation; use parameters or the ORM's parameterized APIs.
+- Never deserialize untrusted data with `BinaryFormatter` or with type-name handling (such as Newtonsoft `TypeNameHandling` other than `None`) that lets the payload choose the type.
+- Avoid enumerating an `IEnumerable<T>` or LINQ query more than once; materialize it with `ToList()` when you need it twice.
+- Run `dotnet build` with warnings visible and `dotnet test`, and use the project's configured formatter and analyzers.
+
+For more, load the csharp-patterns and csharp-testing skills.

package/rules/dart.md

@@ -0,0 +1,29 @@
+---
+name: dart
+description: Always-on rules for Dart and Flutter code, covering null safety, async, widget lifecycle, analysis, formatting and tests.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.dart"
+  kete-loom/owner: "Kete-org"
+---
+
+- Run `dart analyze` (or `flutter analyze`) and fix every issue you introduce. Respect the project's `analysis_options.yaml`; never add `// ignore:` to silence a real problem.
+- Format with `dart format`. Do not hand-format against it.
+- Make a type nullable only when absence is a real state. Promote with a null check or a local copy; use `!` only for an invariant the analyzer cannot see, never to silence an error.
+- Use `late` only when the value is always set before first read; reading it earlier throws at runtime.
+- Never `as`-cast decoded JSON blindly; check shape and types (patterns or explicit checks) before use.
+- Await every `Future` or mark intentional fire-and-forget with `unawaited(...)`. Unawaited errors escape every `try`.
+- Catch specific types with `on`, and use `rethrow` (not `throw e`) to keep the stack trace.
+- Don't add a `_` default to a switch over a sealed type or enum; it hides new cases from the exhaustiveness check.
+- In Flutter, check `mounted` (or `context.mounted`) after any `await` before using `BuildContext` or calling `setState`.
+- In `dispose()`, dispose every controller and `FocusNode` you create and cancel every `StreamSubscription` and `Timer`.
+- Never do I/O or heavy work in `build()`; it must be fast and side-effect free.
+- Use the project's state management and routing approach; do not introduce a new one.
+- Give list items in reorderable or stateful lists a stable `Key`.
+- Never ship secrets in an app, in source or via `--dart-define`; anything in the binary is readable.
+- Add or update tests with `package:test` or `flutter_test` for changed logic; run `dart test` or `flutter test`.
+
+For more, load the dart-patterns, dart-testing and flutter-patterns skills.

package/rules/fsharp.md

@@ -0,0 +1,28 @@
+---
+name: fsharp
+description: Always-on rules for F# code, covering immutability, discriminated unions and exhaustive matching, Option and Result, async and task code, .NET interop, and checks.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.fs, **/*.fsi, **/*.fsx"
+  kete-loom/owner: "Kete-org"
+---
+
+- Prefer immutable values, records and F# collections; use `mutable` or `ref` only for local, contained state.
+- Model closed sets of cases with discriminated unions and match them exhaustively; never ignore incomplete-match warnings.
+- Avoid the wildcard `_` case over a union you own, so a new case is a compile warning at every match.
+- Use `Option` for absence and `Result` for expected failures; keep exceptions for truly exceptional conditions.
+- Never call `Option.get`, `List.head` or `.Value` on something that can be empty; match on it or use a safe function such as `List.tryHead`.
+- Convert nulls from .NET APIs at the boundary with `Option.ofObj` or `Option.ofNullable`.
+- Keep file order in the project file meaningful: a file only uses what is defined above it, so put new types before their users.
+- Never block on async work with `Async.RunSynchronously` or `.Result` inside library or server code; compose with `async { }` or `task { }`.
+- Pass a `CancellationToken` through async and task workflows that do I/O.
+- Dispose resources with `use` or `use!`, not `let`.
+- Never build SQL by string concatenation; use parameters or the data library's parameterized API.
+- Annotate parameter and return types on public functions so an inference change cannot silently change the API.
+- Treat compiler warnings as errors where the project does, and run `dotnet build` and `dotnet test` before finishing.
+- Use the project's configured formatter and test framework.
+
+For more, load the fsharp-patterns and fsharp-testing skills.

package/rules/git.md

@@ -0,0 +1,26 @@
+---
+name: git
+description: Always-on git hygiene rules for agents, covering small focused commits, Conventional Commits messages, keeping secrets and generated files out, safe pushing and never rewriting shared history.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: devops
+  kete-loom/risk: read-only
+  kete-loom/owner: "Kete-org"
+---
+
+- Never commit directly to the default branch unless that is the project's workflow; branch first.
+- Run `git status` and `git diff --staged` before every commit and check that only the intended changes are staged.
+- Stage files by name. Avoid `git add -A` or `git add .` when unrelated or untracked files are present.
+- Keep each commit small and focused on one logical change that builds and passes tests on its own.
+- Follow the project's commit message convention (check recent `git log`); if it has none, use Conventional Commits, `type(scope): summary`. Write the summary in the imperative and add a body that explains why when the reason is not obvious.
+- Never commit secrets, `.env` files, credentials, private keys or personal data. If one was committed, stop and tell the user; removing it from history does not un-leak it, so it must be rotated.
+- Never commit build output, dependency folders, caches or editor files. Keep lockfiles the project already tracks in sync with its manifest.
+- Never skip hooks with `--no-verify`. If a hook fails, fix the cause and commit again; do not amend an earlier commit to work around it.
+- Never force-push a shared branch or rewrite published history. On your own branch, use `--force-with-lease`, never plain `--force`.
+- Never run destructive commands (`reset --hard`, `clean -fd`, `checkout -- .`, `branch -D`, `stash drop`) without the user's consent; they discard uncommitted work.
+- Do not change git config, remotes or signing settings unless asked.
+- Use non-interactive commands; avoid flags that open an editor or prompt, such as `rebase -i` or `add -p`.
+- Resolve merge conflicts by reading both sides; never accept one side wholesale to make the conflict go away.
+
+For more, load the git-workflow and conventional-commits skills.

package/rules/go.md

@@ -0,0 +1,29 @@
+---
+name: go
+description: Always-on rules for Go files, covering formatting, vet, error handling, context, goroutine and resource lifetimes, and concurrency safety.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.go"
+  kete-loom/owner: "Kete-org"
+---
+
+- Format with `gofmt` (or the project's `goimports`). Run `go vet ./...` and `go test ./...` after a change, plus the project's configured linter.
+- Run tests with `-race` when the code uses goroutines or shared state.
+- Check every returned error. Never discard one with `_` unless a comment says why.
+- Wrap errors with context using `fmt.Errorf("doing x: %w", err)`, and inspect them with `errors.Is` and `errors.As`, never by comparing strings.
+- Handle an error or return it, not both: do not log and then return the same error.
+- Never `panic` for expected failures in library code; return an error.
+- Pass `context.Context` as the first parameter of anything that does I/O or may block, and honour its cancellation. Never store it in a struct.
+- `defer` the `Close` of files, response bodies and rows right after the error check; check `rows.Err()` after iterating.
+- Give every goroutine a way to stop (context, closed channel or `sync.WaitGroup`). Never start one you cannot end.
+- Protect shared state with a mutex or channels. Never copy a value that contains a `sync.Mutex`.
+- Only the sender closes a channel. Never close a channel twice or send on a closed one.
+- Set a timeout on outbound HTTP calls (client `Timeout` or a context deadline); `http.Get` and `http.DefaultClient` have none. Set `ReadHeaderTimeout` on `http.Server`.
+- Use parameterized queries in `database/sql`; never build SQL with `fmt.Sprintf`.
+- Pass `exec.Command` separate arguments; never run `sh -c` with a string built from input.
+- Keep `go.mod` and `go.sum` tidy with `go mod tidy`; never edit `go.sum` by hand.
+
+For more, load the go-patterns and go-testing skills.

package/rules/java.md

@@ -0,0 +1,29 @@
+---
+name: java
+description: Always-on rules for Java files, covering build tooling, null handling, exceptions, resources, concurrency and injection safety.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.java"
+  kete-loom/owner: "Kete-org"
+---
+
+- Use the project's build tool through its wrapper (`./mvnw` or `./gradlew`), not a globally installed `mvn` or `gradle`.
+- Use the project's configured formatter and static analysis; never disable a check to make the build pass.
+- Use `try`-with-resources for streams, readers, connections and statements so they always close.
+- Never catch and ignore an exception. Catch the narrowest type, and pass the original as the cause when wrapping.
+- Never catch `Throwable` or `Error`; when catching `InterruptedException`, restore the flag with `Thread.currentThread().interrupt()`.
+- Return empty collections or `Optional`, not `null`. Use `Optional` only as a return type, never for fields or parameters.
+- Validate parameters at public boundaries with `Objects.requireNonNull` or explicit checks.
+- Override `equals` and `hashCode` together, never one alone.
+- Compare strings and boxed numbers with `equals`, never `==`.
+- Pass an explicit `Charset` (`StandardCharsets.UTF_8`) when converting bytes and text.
+- Use `java.time` (`Instant`, `LocalDate`, `ZonedDateTime`), never `Date` or `Calendar` in new code.
+- Use `PreparedStatement` or the framework's parameter binding; never concatenate user input into SQL or JPQL. Run processes with `ProcessBuilder` and an argument list.
+- Never deserialize untrusted data with `ObjectInputStream`. Disable external entities when parsing untrusted XML.
+- Run concurrent work on an `ExecutorService` (or the framework's executor) and shut it down, rather than unmanaged `new Thread(...)`. Guard shared mutable state with `java.util.concurrent` types or locks.
+- Use `SecureRandom`, not `Random`, for tokens and keys.
+
+For more, load the java-patterns and java-testing skills.

package/rules/kotlin.md

@@ -0,0 +1,27 @@
+---
+name: kotlin
+description: Always-on rules for Kotlin code, covering null safety, sealed types, coroutines and structured concurrency, Java interop, and build and test checks.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.kt, **/*.kts"
+  kete-loom/owner: "Kete-org"
+---
+
+- Never use `!!` in new code. Use `?:` with an early return or error, `requireNotNull`/`checkNotNull`, or a non-null type validated at the boundary.
+- Give values from unannotated Java APIs an explicit Kotlin type at the call site so a null fails where it enters.
+- Use `lateinit var` only for values a framework sets before first use, never for values that can be missing.
+- Prefer `val` and read-only collection types; never put mutable collections in a `data class`, since `copy()` shares them.
+- Model closed sets of states with `sealed interface` or `sealed class`, and match them with `when` as an expression with no `else`.
+- Never use `GlobalScope`. Launch coroutines in a scope tied to a lifecycle and let structured concurrency cancel them.
+- Never block a coroutine thread with `Thread.sleep` or blocking I/O; use `delay`, suspending APIs, or `withContext(Dispatchers.IO)`.
+- Never swallow `CancellationException`. When catching `Exception` or `Throwable` (or using `runCatching`) in suspending code, rethrow it.
+- Do not use `runBlocking` in production code paths; keep it to `main` and tests that cannot use `runTest`.
+- Make shared mutable state safe with `Mutex`, atomics or confinement to one dispatcher; never mutate it from several coroutines unguarded.
+- Use `use { }` on every `Closeable` so it is closed on all paths.
+- Use the project's configured build (Gradle or Maven), formatter and linter, and run its tests before finishing.
+- Test suspending code with `runTest` from kotlinx-coroutines-test, not `runBlocking` with real delays.
+
+For more, load the kotlin-patterns and kotlin-testing skills.

package/rules/perl.md

@@ -0,0 +1,26 @@
+---
+name: perl
+description: Always-on rules for modern Perl 5 code, covering strict and warnings, lexical scope, safe open and system calls, untrusted input, SQL, encoding and tests.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.pl, **/*.pm, **/*.t, **/*.psgi"
+  kete-loom/owner: "Kete-org"
+---
+
+- Start every file with `use strict;` and `use warnings;` (or the project's equivalent bundle, such as `use v5.36;`).
+- Declare variables with `my` in the smallest scope. Never use undeclared globals; use `our` only for package interfaces.
+- Use three-argument `open` with a lexical filehandle and check it: `open(my $fh, '<', $path) or die "Can't open $path: $!";`.
+- Check the result of every system call (`open`, `close`, `mkdir`, `unlink`, `rename`) and include `$!` in the error, or `use autodie`.
+- Call external programs with list-form `system` or `exec` (`system('cmd', @args)`), never one interpolated string. Check `$?` afterwards.
+- Never pass untrusted input to string `eval`, two-argument `open`, or backticks. Catch exceptions with block `eval { }` or the project's try/catch module.
+- Localise special variables (`local $_`, `local $/`) when you change them.
+- Use placeholders (`?`) with DBI `prepare`/`execute`; never interpolate values into SQL.
+- Pass and return complex data by reference; don't flatten hashes and arrays you need to keep separate.
+- Decode input and encode output explicitly (`use utf8;` when the source has non-ASCII text, `:encoding(UTF-8)` layers on handles).
+- Run `perl -c` and the project's configured Perl::Critic and Perl::Tidy settings on changed files.
+- Write tests in `t/*.t` with `Test::More` (or the project's framework), end with `done_testing`, and run them with `prove -lr t`.
+
+For more, load the perl-patterns and perl-testing skills.

package/rules/php.md

@@ -0,0 +1,28 @@
+---
+name: php
+description: Always-on rules for modern PHP 8 code, covering strict types, typed signatures, input handling, SQL, errors, Composer and tests.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.php"
+  kete-loom/owner: "Kete-org"
+---
+
+- Start new files with `declare(strict_types=1);` and match existing files that already use it.
+- Type every parameter, return and property. Use `?T` or union types only when null or another type is a real state.
+- Use enums for fixed sets of values when the project's PHP version supports them (8.1+), not loose strings.
+- Compare with `===` and `!==`. Use `match` over `switch` when mapping values; it compares strictly and throws `UnhandledMatchError` on no match.
+- Never build SQL by string concatenation. Use prepared statements with bound parameters (PDO or the project's query builder/ORM).
+- Escape output for its context: `htmlspecialchars($v, ENT_QUOTES, 'UTF-8')` for HTML, or the template engine's auto-escaping.
+- Never pass user input to `eval`, `include`/`require`, `unserialize`, `exec`, `shell_exec` or `system`. Use `json_decode` for untrusted data and `escapeshellarg` if a shell is unavoidable.
+- Hash passwords with `password_hash` and check with `password_verify`. Use `random_bytes`/`random_int` for tokens, never `rand` or `mt_rand`.
+- Throw specific exceptions and catch them where you can act. Never suppress errors with `@`.
+- Run the project's configured formatter and code style tool; keep classes in PSR-4 autoload paths (one class per file, namespace matches directory).
+- Run the project's static analyser (PHPStan or Psalm) at its configured level and fix what you introduce.
+- Add dependencies with `composer require`, commit `composer.lock` in applications, and never edit `vendor/`.
+- Validate request input at the boundary; never trust `$_GET`, `$_POST`, `$_COOKIE` or headers.
+- Add or update tests with the project's test framework (PHPUnit or Pest) and run them.
+
+For more, load the php-patterns, php-testing and laravel-patterns skills.

package/rules/python.md

@@ -0,0 +1,30 @@
+---
+name: python
+description: Always-on rules for Python 3 files, covering environments, type hints, exceptions, resource handling, untrusted input and the project's own tooling.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.py, **/*.pyi"
+  kete-loom/owner: "Kete-org"
+---
+
+- Use the project's environment and dependency tool (its lockfile or `pyproject.toml` shows which). Never install packages into the system Python.
+- Use the project's configured formatter, linter, type checker and test runner, and run them after a change.
+- Where the project uses type hints, add them to new and changed function signatures. Never use `# type: ignore` without a specific error code and a reason.
+- Never use a mutable default argument (`def f(x=[])`); default to `None` and create the value inside.
+- Never use a bare `except:` or `except Exception: pass`. Catch the narrowest exception, and use `raise ... from err` when wrapping.
+- Open files, locks, connections and sockets with `with` so they always close.
+- Pass `encoding="utf-8"` when opening text files.
+- Resolve any path built from user input and check it stays inside the allowed directory before using it.
+- Never pass user input to `eval`, `exec`, `pickle.loads`, `yaml.load` without `SafeLoader`, or `subprocess` with `shell=True`. Pass `subprocess` an argument list.
+- Use parameterized queries; never format SQL with f-strings or `%`.
+- Use `secrets`, not `random`, for tokens and passwords.
+- Use timezone-aware datetimes (`datetime.now(timezone.utc)`); never compare naive and aware values.
+- Use `logging` in library code, not `print`.
+- Set a timeout on every network call; `requests` and `urllib` wait forever by default.
+- Never call blocking I/O inside `async def`; use an async library or `asyncio.to_thread`.
+- Compare to `None` with `is` / `is not`.
+
+For more, load the python-patterns and python-testing skills.

package/rules/ruby.md

@@ -0,0 +1,27 @@
+---
+name: ruby
+description: Always-on rules for Ruby code, covering style, nil handling, exceptions, unsafe input, Bundler, Rails safety and tests.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.rb, **/*.rake, **/*.erb, **/*.gemspec, **/Gemfile, **/Rakefile"
+  kete-loom/owner: "Kete-org"
+---
+
+- Run the project's configured linter and formatter (RuboCop or Standard) and fix what you introduce. Don't add inline disables to hide real problems.
+- Match the project's use of `# frozen_string_literal: true`; don't mutate string literals.
+- Handle `nil` explicitly. Use `fetch` for required keys so a missing key raises instead of returning `nil`; use `&.` only where `nil` is a valid state.
+- Rescue specific exception classes. Never `rescue Exception` (it catches `Interrupt` and `SystemExit`); re-raise with bare `raise` when you can't handle it.
+- Use `ensure` or block forms (`File.open { }`) so resources are always released.
+- Never pass user input to `eval`, `instance_eval`, `send`, `public_send`, `constantize` or `Object.const_get` without an allowlist.
+- Call shell commands with argument arrays (`system("cmd", arg)`, `Open3.capture3("cmd", arg)`), never interpolated strings or backticks.
+- Never use `Marshal.load` or `YAML.load` on untrusted data; use `JSON.parse` or `YAML.safe_load`.
+- In Rails, never interpolate into SQL; use `where(name: v)` or bound placeholders. Permit params with strong parameters, never `permit!`.
+- In Rails views, never call `html_safe` or `raw` on user input; let ERB escape it.
+- In Rails, avoid N+1 queries with `includes`/`preload`, and change the schema only through migrations.
+- Add gems through the `Gemfile` with Bundler and commit `Gemfile.lock`. Run commands with `bundle exec`.
+- Add or update tests with the project's framework (RSpec or Minitest) and run them.
+
+For more, load the ruby-patterns, ruby-testing and rails-patterns skills.

package/rules/rust.md

@@ -0,0 +1,26 @@
+---
+name: rust
+description: Always-on rules for Rust files, covering cargo tooling, error handling, panics, unsafe code, async and dependency hygiene.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.rs"
+  kete-loom/owner: "Kete-org"
+---
+
+- Run `cargo fmt`, `cargo clippy --all-targets` and `cargo test` after a change. Fix clippy warnings instead of adding `#[allow]` without a reason.
+- Return `Result` for recoverable failures and propagate with `?`. Add context to errors as they cross a boundary.
+- Use the project's error approach (often `thiserror` for libraries, `anyhow` for applications); never return `Box<dyn Error>` or `String` errors from a public library API without reason.
+- Never use `unwrap()` or `expect()` on input, I/O or anything that can fail at runtime outside tests. Use `expect("why this cannot fail")` only for true invariants.
+- Avoid code that can panic on untrusted input: indexing with `[]`, slicing strings at byte offsets, and unchecked arithmetic (it panics in debug and wraps silently in release). Use `get`, `checked_*` or `saturating_*`.
+- Write `unsafe` only when it is required, keep the block minimal, and add a `// SAFETY:` comment stating the invariant it relies on.
+- Never hold a `std::sync::Mutex` guard across an `.await`; drop it first or use the async runtime's mutex.
+- Never call blocking I/O or long CPU work directly in async code; use the runtime's blocking task facility (such as `spawn_blocking`).
+- Never log or `Debug`-print secrets; implement `Debug` by hand for types that hold them.
+- Use parameterized queries in database code; never build SQL with `format!`.
+- Pass `std::process::Command` separate `.arg()` values; never run `sh -c` with a string built from input.
+- Commit `Cargo.lock` (always for binaries; Cargo now recommends it for libraries too). Do not add a dependency for a few lines of code.
+
+For more, load the rust-patterns and rust-testing skills.

package/rules/security.md

@@ -0,0 +1,29 @@
+---
+name: security
+description: Always-on secure coding rules for any language, covering input validation, injection, authorization, least privilege, deserialisation, dependencies and keeping secrets and personal data out of logs.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: security
+  kete-loom/risk: read-only
+  kete-loom/owner: "Kete-org"
+---
+
+- Treat all external input as untrusted: request data, headers, cookies, uploaded files, queue messages, LLM output and third-party API responses.
+- Validate input at the trust boundary against an allowlist of type, length, range and format. Reject what fails; do not try to clean it up.
+- Use parameterised queries or the ORM's bound parameters. Never build SQL, NoSQL or LDAP queries by string concatenation or formatting.
+- Run external commands with an argument array and no shell. Never pass user input into a shell string, `eval` or dynamic code execution.
+- Encode output for its context (HTML, attribute, URL, JS) and use the framework's auto-escaping; never mark untrusted data as safe.
+- Resolve user-supplied file paths against a fixed base directory and reject any result outside it.
+- Enforce authentication and authorization on the server for every request and every object accessed. Hidden UI or client checks are not access control.
+- Grant least privilege: minimal scopes for tokens, database users, service accounts, CI jobs and file permissions.
+- Never deserialise untrusted data with formats that can run code (`pickle`, Java native serialization, unsafe YAML loaders). Use JSON or a safe loader with a schema.
+- Validate outbound URLs built from user input against an allowlist of hosts to prevent SSRF.
+- Use the platform's vetted crypto and password-hashing libraries and a cryptographically secure random source for tokens. Never write your own crypto.
+- Keep TLS certificate verification on. Never disable it to make a request work.
+- Never log secrets, tokens, passwords, session IDs or personal data. Redact them in errors, traces and analytics too.
+- Return generic error messages to clients; keep stack traces and internal details in server logs.
+- Add dependencies only when needed, from the official registry, pinned through the lockfile. Check the name for typosquats and run the project's audit tool after changes.
+- Default to secure configuration: deny by default, `Secure`, `HttpOnly` and `SameSite` on session cookies, CSRF protection on state-changing requests that use cookie auth, debug mode off in production.
+
+For more, load the security-review skill.

package/rules/swift.md

@@ -0,0 +1,28 @@
+---
+name: swift
+description: Always-on rules for Swift code, covering optionals, value types, error handling, Swift concurrency and actors, memory and retain cycles, and build and test checks.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.swift"
+  kete-loom/owner: "Kete-org"
+---
+
+- Never use `!`, `try!` or `as!` on values that can fail at runtime; use `guard let`, `if let`, `??`, `as?` or a thrown error.
+- Avoid implicitly unwrapped optionals except for values a framework sets before first use, such as outlets.
+- Prefer `let` over `var`, and `struct` or `enum` for data; use `class` when you need identity or shared mutable state.
+- Switch over enums exhaustively; avoid `default` on enums you own so a new case is a compile error, and use `@unknown default` for non-frozen SDK enums.
+- Throw specific, meaningful errors and handle them with `do`/`catch`; never discard them with `try?` where the failure matters.
+- Use `async`/`await` and structured concurrency (`async let`, task groups) over completion handlers in new code.
+- Protect shared mutable state with an `actor` or `@MainActor`; never mutate it from several tasks unguarded.
+- Update UI only on the main actor.
+- Make types that cross concurrency domains `Sendable`, and fix concurrency warnings; use `@unchecked Sendable` or `nonisolated(unsafe)` only when you add the synchronization yourself and say why in a comment.
+- Check `Task.isCancelled` or call `try Task.checkCancellation()` in long-running work.
+- Capture `self` weakly (`[weak self]`) in escaping closures stored by `self` or its children, to avoid retain cycles.
+- Mark delegate properties `weak`.
+- Never store secrets in `UserDefaults` or plain files; use the Keychain.
+- Build and test with the project's configured tooling (`swift build` and `swift test` for packages, or the Xcode scheme), and use its configured formatter or linter.
+
+For more, load the swift-patterns and swift-testing skills.

package/rules/testing.md

@@ -0,0 +1,25 @@
+---
+name: testing
+description: Always-on rules for writing and running tests in any language, covering behaviour-focused tests, failing tests first for bugs, determinism, isolation, speed and running the suite before finishing.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: testing
+  kete-loom/risk: read-only
+  kete-loom/owner: "Kete-org"
+---
+
+- Use the project's configured test framework, runner and file layout. Do not add a second one.
+- Test behaviour through the public interface: inputs, outputs and observable effects. Do not assert on private methods or internal call order.
+- For a bug, first write a test that reproduces it and watch it fail, then fix the code until it passes.
+- Give each test one reason to fail and a name that says the expected behaviour.
+- Cover edge cases and error paths, not just the happy path: empty, boundary, invalid and failing-dependency inputs.
+- Make tests deterministic. Inject or fake the clock, seed any randomness and never depend on test order, wall-clock time or time zone.
+- Never use fixed sleeps to wait. Wait on a condition with a timeout, or use fake timers.
+- Keep tests isolated: each test sets up and tears down its own state, uses temporary directories and never relies on shared mutable globals.
+- Never call the real network or third-party services in unit tests. Fake slow or nondeterministic boundaries (network, clock, external APIs); use real objects for the code under test.
+- Keep unit tests fast; move slow integration and end-to-end tests to their own suite.
+- A flaky test is a bug: find the cause instead of adding retries.
+- Run the relevant tests after every change and the full suite before finishing.
+
+For more, load the tdd-workflow skill and the testing skill for your language, such as python-testing or typescript-testing.

package/rules/typescript.md

@@ -0,0 +1,29 @@
+---
+name: typescript
+description: Always-on rules for TypeScript and JavaScript files, covering type safety, untrusted input, async errors, modules and the project's own tooling.
+license: MIT
+metadata:
+  kete-loom/version: "0.1.0"
+  kete-loom/category: coding
+  kete-loom/risk: read-only
+  kete-loom/paths: "**/*.ts, **/*.tsx, **/*.mts, **/*.cts, **/*.js, **/*.jsx, **/*.mjs, **/*.cjs"
+  kete-loom/owner: "Kete-org"
+---
+
+- Use the project's package manager (the one its lockfile belongs to), formatter, linter and test runner. Never add a second lockfile.
+- Run the project's type check (often `tsc --noEmit`) and lint after a change, not only the tests.
+- Never weaken `tsconfig.json` or lint settings to make an error go away.
+- Never silence the compiler with `any`, `as any`, `@ts-ignore` or a `!` non-null assertion. If a suppression is truly needed, use `@ts-expect-error` with a reason.
+- Type values you have not checked as `unknown` and narrow them. Validate untrusted input (request bodies, `JSON.parse`, env vars, files) at the boundary with the project's schema library or a type guard.
+- End a `switch` over a union with a `never` check so a new case fails to compile.
+- Use `const` by default, `let` when reassigned, never `var`. Use `===` and `!==` (the project's `== null` idiom aside).
+- Await or return every promise, or mark it with `void` and handle its rejection. Never leave a floating promise.
+- Never pass an async function to `forEach`; use `for...of` with `await`, or `Promise.all` / `Promise.allSettled` over `map`.
+- Catch errors as `unknown`, and throw `Error` objects, never strings. Pass the original as `{ cause }` when wrapping.
+- Use `?.` and `??` for missing values; `||` also replaces `0`, `""` and `false`.
+- Never build HTML, SQL, shell commands or file paths by string concatenation with user input. Use parameterized queries, `execFile`/`spawn` with an argument array, and the framework's escaping.
+- Never use `eval`, `new Function` or `innerHTML` with untrusted data.
+- Match the package's module system (`"type"` in `package.json`, `.mjs`/`.cjs`); never mix `require` and `import` in one file.
+- Never put secrets in client code or in env vars the framework exposes to the browser (such as `NEXT_PUBLIC_` or `VITE_`).
+
+For more, load the typescript-patterns and typescript-testing skills.

package/schemas/skill-frontmatter.schema.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ketecode.ai/schemas/kete-loom/skill-frontmatter.schema.json",
+  "title": "Kete Loom SKILL.md frontmatter",
+  "description": "The strictest common subset of the Agent Skills spec (agentskills.io) as read by Claude Code, Codex, OpenCode, Cursor, Gemini CLI and GitHub Copilot, plus Kete Loom's metadata keys. Extra keys live under `metadata` as strings, because OpenCode requires metadata to be a string-to-string map.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["name", "description", "license", "metadata"],
+  "properties": {
+    "name": {
+      "type": "string",
+      "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
+      "minLength": 1,
+      "maxLength": 64,
+      "description": "Must equal the skill's folder name."
+    },
+    "description": {
+      "type": "string",
+      "minLength": 80,
+      "maxLength": 1024,
+      "description": "Single line. Says what the skill does AND when to use it (contains 'Use when')."
+    },
+    "license": { "type": "string" },
+    "compatibility": {
+      "type": "string",
+      "maxLength": 500,
+      "description": "Plain-language environment requirements (tools, network, OS)."
+    },
+    "metadata": {
+      "type": "object",
+      "additionalProperties": { "type": "string" },
+      "required": ["kete-loom/version", "kete-loom/category", "kete-loom/risk"],
+      "properties": {
+        "kete-loom/version": { "type": "string", "pattern": "^\\d+\\.\\d+\\.\\d+$" },
+        "kete-loom/category": {
+          "type": "string",
+          "enum": ["coding", "testing", "security", "integrations", "devops", "data", "ai", "docs", "business", "compliance", "meta"]
+        },
+        "kete-loom/risk": {
+          "type": "string",
+          "enum": ["read-only", "writes-files", "runs-commands", "network"],
+          "description": "Highest-impact action the skill instructs the agent to take."
+        },
+        "kete-loom/requires": {
+          "type": "string",
+          "description": "Comma-separated CLIs or runtimes the skill expects, e.g. 'git, node'."
+        },
+        "kete-loom/owner": { "type": "string" }
+      }
+    }
+  }
+}

package/scripts/lib/audit.js

@@ -0,0 +1,96 @@
+'use strict';
+
+// `kete-loom audit`: a deterministic readiness scorecard for working on a project with coding agents.
+// Same input, same result: it reads files and runs read-only git commands, never a model.
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { detect } = require('./profiles');
+const { inventory } = require('./inventory');
+
+const CODEX_MAX_BYTES = 32768;
+const DETECT_CHECKS = path.join(__dirname, '..', '..', 'skills', 'verification-loop', 'scripts', 'detect-checks.js');
+
+const git = (cwd, args) => {
+  try {
+    return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }).trim();
+  } catch {
+    return null;
+  }
+};
+
+function audit({ cwd = process.cwd(), home, catalog }) {
+  const checks = [];
+  const add = (id, status, title, detail, fix) => checks.push({ id, status, title, detail, ...(fix ? { fix } : {}) });
+  const root = git(cwd, ['rev-parse', '--show-toplevel']) || cwd;
+  const has = (f) => fs.existsSync(path.join(root, f));
+
+  if (git(cwd, ['rev-parse', '--is-inside-work-tree']) === 'true') add('git', 'pass', 'Git repository', 'Agents can see history, diffs and status.');
+  else add('git', 'warn', 'Git repository', 'This folder is not a git repository, so agents can\'t diff, review or roll back their changes.', 'git init');
+
+  const instr = ['AGENTS.md', 'CLAUDE.md'].filter(has);
+  if (!instr.length) add('instructions', 'fail', 'Agent instructions', 'No AGENTS.md or CLAUDE.md: every agent starts without your build commands, conventions or boundaries.', 'Write AGENTS.md (the /project-init command or the codebase-onboarding skill can draft it)');
+  else {
+    const big = instr.filter((f) => fs.statSync(path.join(root, f)).size > CODEX_MAX_BYTES);
+    if (big.length) add('instructions', 'warn', 'Agent instructions', `${big.join(', ')} is over 32 KiB; Codex stops reading there and every host pays for it on every turn.`, 'Move detail into skills, rules or linked docs');
+    else add('instructions', 'pass', 'Agent instructions', `${instr.join(' and ')} present.`);
+  }
+
+  const found = detect(root);
+  const installedRows = [...inventory({ scope: 'user', home, cwd: root }), ...inventory({ scope: 'project', home, cwd: root })];
+  const installedNames = new Set(installedRows.map((r) => r.name));
+  if (!found.length) add('packs', 'pass', 'Packs for this stack', 'No language or framework detected that Kete Loom has a pack for.');
+  else {
+    const want = [...new Set(found.flatMap((d) => [...(d.skills || []), ...(d.agents || []), ...(d.rules || [])]))].filter((n) => ['skills', 'agents', 'rules'].some((k) => (catalog[k] || []).some((i) => i.dir === n)));
+    const missing = want.filter((n) => !installedNames.has(n));
+    const stack = found.map((d) => d.what).join(', ');
+    if (!missing.length) add('packs', 'pass', 'Packs for this stack', `Installed for ${stack}.`);
+    else add('packs', missing.length === want.length ? 'fail' : 'warn', 'Packs for this stack', `Detected ${stack}; missing ${missing.length} of ${want.length}: ${missing.slice(0, 8).join(', ')}${missing.length > 8 ? '…' : ''}.`, 'npx @ketecode/loom install --profile core   (run it in this project)');
+  }
+
+  let commands = [];
+  try {
+    commands = JSON.parse(execFileSync(process.execPath, [DETECT_CHECKS, root], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 })).checks || [];
+  } catch (e) {
+    // detect-checks exits 3 when it finds nothing; its JSON is still on stdout.
+    try {
+      commands = JSON.parse(e.stdout || '{}').checks || [];
+    } catch {
+      commands = [];
+    }
+  }
+  const kinds = new Set(commands.map((c) => c.kind));
+  if (!kinds.has('test')) add('verification', 'fail', 'Verification commands', 'No test command found, so agents can\'t prove a change works.', 'Add a test script (package.json "test", Makefile "test", pytest config…) and name it in AGENTS.md');
+  else if (!kinds.has('lint') && !kinds.has('typecheck')) add('verification', 'warn', 'Verification commands', `Tests found (${commands.find((c) => c.kind === 'test').command}), but no lint or type-check command.`, 'Add a lint or type-check script so agents catch mistakes before tests');
+  else add('verification', 'pass', 'Verification commands', commands.map((c) => c.command).join(', '));
+
+  const ci = ['.github/workflows', '.gitlab-ci.yml', '.circleci', 'azure-pipelines.yml', 'bitbucket-pipelines.yml', 'Jenkinsfile', '.buildkite'].filter(has);
+  if (ci.length) add('ci', 'pass', 'Continuous integration', `${ci.join(', ')}.`);
+  else add('ci', 'warn', 'Continuous integration', 'No CI configuration found, so nothing re-checks what agents push.', 'Add CI that runs the same build, lint and test commands (the github-actions-ci skill can set it up)');
+
+  const hooks = new Set(installedRows.filter((r) => r.kind === 'hooks').map((r) => r.name));
+  const safety = ['block-dangerous-commands', 'guard-secrets'];
+  const missingHooks = safety.filter((h) => !hooks.has(h));
+  if (!missingHooks.length) add('hooks', 'pass', 'Safety hooks', `${safety.join(' and ')} are installed.`);
+  else add('hooks', 'warn', 'Safety hooks', `Not installed: ${missingHooks.join(', ')}. Nothing stops an agent from running rm -rf ~ or writing a key into a file.`, `npx @ketecode/loom install --hook ${missingHooks.join(',')}`);
+
+  const tracked = (git(root, ['ls-files']) || '').split('\n').filter((f) => /(^|\/)\.env(\.[^/]*)?$/.test(f) && !/\.(example|sample|template|dist|defaults)$/.test(f));
+  const ignore = has('.gitignore') ? fs.readFileSync(path.join(root, '.gitignore'), 'utf8') : '';
+  if (tracked.length) add('secrets', 'fail', 'Secrets', `Committed environment files: ${tracked.join(', ')}. Anything in them is in git history.`, 'git rm --cached the files, add .env* to .gitignore, and rotate every secret they held');
+  else if (!/^\s*\/?\.env\*?\s*$|^\s*\.\*\s*$|^\s*\*\.env\s*$/m.test(ignore)) add('secrets', 'warn', 'Secrets', '.gitignore does not ignore .env files, so the next one created can be committed by accident.', 'Add .env and .env.* to .gitignore (keep .env.example tracked)');
+  else add('secrets', 'pass', 'Secrets', 'No environment files committed, and .gitignore covers them.');
+
+  if (has('package.json')) {
+    const locks = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb', 'npm-shrinkwrap.json'].filter(has);
+    if (locks.length) add('lockfile', 'pass', 'Dependency lockfile', locks.join(', '));
+    else add('lockfile', 'warn', 'Dependency lockfile', 'package.json without a lockfile: agents and CI can resolve different dependency versions.', 'Run your package manager\'s install and commit the lockfile');
+  }
+
+  const weight = { pass: 1, warn: 0.5, fail: 0 };
+  const score = Math.round((checks.reduce((n, c) => n + weight[c.status], 0) / checks.length) * 100);
+  const order = { fail: 0, warn: 1, pass: 2 };
+  return { root, score, checks: checks.sort((a, b) => order[a.status] - order[b.status]) };
+}
+
+module.exports = { audit };