@deslop/coding-standards 0.1.1063 → 0.1.1065

package/README.md

@@ -10,7 +10,7 @@ Run inside a Git repository, including a linked worktree:
 vpx @deslop/coding-standards@latest
 ```
 
-It copies the three skills into the repository's existing `.agents`, `.claude` and `.codex` directories. It always writes `.claude`, which Claude Code reads, and writes `.agents` when no `.codex` exists. A refresh replaces only those three skills, and destinations outside the repository or inside global agent configuration are rejected. Nothing is added to the manifest, lockfile or lint configuration. Installed copies are read-only; refresh them with the CLI.
+It copies the three skills into the repository's existing `.agents`, `.claude` and `.codex` directories, including their `EVALS.md`. It always writes `.claude`, which Claude Code reads, and writes `.agents` when no `.codex` exists. A refresh replaces only those three skills, and destinations outside the repository or inside global agent configuration are rejected. Nothing is added to the manifest, lockfile or lint configuration. Edit package sources; refresh installed copies with the CLI.
 
 ## Use the lint preset
 

package/dist/{MutableRef-CzOzKHjT.mjs → MutableRef-WrqsqeER.mjs}

@@ -5666,6 +5666,32 @@ const some = /*#__PURE__*/ dual(2, (self, predicate) => self.some(predicate));
 */
 const makeEquivalence = Array_;
 /**
+* Runs a side-effect for each element. The callback receives `(element, index)`.
+*
+* **When to use**
+*
+* Use to iterate over an array for side-effects only, when no transformed
+* result is needed.
+*
+* **Example** (Iterating with side-effects)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* const visited: Array<number> = []
+* Array.forEach([1, 2, 3], (n) => visited.push(n))
+*
+* visited // => [1, 2, 3]
+* ```
+*
+* @see {@link map} for transforming each element into a new array
+*
+* @stability stable
+* @category traversing
+* @since 2.0.0
+*/
+const forEach = /*#__PURE__*/ dual(2, (self, f) => fromIterable(self).forEach((a, i) => f(a, i)));
+/**
 * Removes duplicates using `Equal.equivalence()`, preserving the order of the
 * first occurrence.
 *
@@ -5912,6 +5938,23 @@ globalThis.String;
 */
 const Order = String$2;
 /**
+* Removes whitespace from both ends of a string.
+*
+* **Example** (Trimming whitespace)
+*
+* ```ts import.meta.vitest
+* import { String } from "effect"
+*
+* String.trim(" a ") // => "a"
+* String.trim("  hello world  ") // => "hello world"
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const trim = (self) => self.trim();
+/**
 * Removes whitespace from the end of a string.
 *
 * **Example** (Trimming trailing whitespace)
@@ -6208,4 +6251,4 @@ const set = /*#__PURE__*/ dual(2, (self, value) => {
 */
 const update = /*#__PURE__*/ dual(2, (self, f) => set(self, f(get(self))));
 //#endregion
-export { fromOption as $, isNotNull as $n, causeDie as $t, getSomes as A, format as An, isGreaterThanOrEqualTo as At, match$1 as B, combine as Bn, Done as Bt, findFirst as C, assignProperty as Cn, Prototype as Cr, some$1 as Ct, flatten as D, BaseProto as Dn, Number$1 as Dt, flatMap as E, setStackTraceLimit as En, Date$1 as Et, isReadonlyArrayNonEmpty as F, currentFiberTypeId as Fn, Tuple as Ft, sort as G, string as Gn, PipeInspectableProto as Gt, prepend as H, number as Hn, ExitTypeId as Ht, join as I, byReferenceUnsafe as In, make$2 as It, get$2 as J, hasProperty as Jn, TaggedError$1 as Jt, take as K, structure as Kn, ReasonBase as Kt, last as L, equals as Ln, strictEqual as Lt, isArrayEmpty as M, formatJson as Mn, isLessThanOrEqualTo as Mt, isArrayNonEmpty as N, formatPath as Nn, make$1 as Nt, fromIterable as O, NodeInspectSymbol as On, String$2 as Ot, isCanonicalArrayIndex as P, formatPropertyKey as Pn, mapInput as Pt, fail as Q, isIterable as Qn, causeCombine as Qt, makeEquivalence as R, symbol as Rn, CauseImpl as Rt, filterMap as S, withFiber as Sn, Class$1 as Sr, orElse as St, findLast as T, getStackTraceLimit as Tn, BigInt as Tt, reduce as U, optimize as Un, Fail as Ut, of as V, hash as Vn, Error$2 as Vt, some as W, random as Wn, InterruptorStackTrace as Wt, remove as X, isError as Xn, args as Xt, map$1 as Y, isBoolean as Yn, Yield as Yt, values as Z, isFunction as Zn, causeAnnotate as Zt, dropRight as _, isExit as _n, dual as _r, isSome as _t, includes as a, contAll as an, isObjectKeyword as ar, all as at, every as b, makePrimitive as bn, memoizeIdempotent as br, match$3 as bt, startsWith as c, evaluate as cn, isString as cr, filter$1 as ct, TaggedError as d, exitFailCause as dn, isUnknown as dr, flatten$1 as dt, causeEmpty as en, isNotNullish as er, getOrThrow as et, taggedEnum as f, exitSucceed as fn, constFalse as fr, fromNullishOr as ft, dedupe as g, isEffect as gn, constant as gr, isNone as gt, contains as h, isDone as hn, constVoid as hr, getOrUndefined as ht, Order as i, contA as in, isObject as ir, normalize as it, head as j, formatDate as jn, isLessThan as jt, get$1 as k, toStringUnknown as kn, isGreaterThan as kt, trimEnd as l, exitDie as ln, isTagged as lr, firstSomeOf as lt, appendAll as m, isDieReason as mn, constUndefined as mr, getOrElse as mt, make as n, causeFromReasons as nn, isNullish as nr, match$2 as nt, match as o, contE as on, isPropertyKey as or, contains$1 as ot, append as p, isCause as pn, constTrue as pr, fromUndefinedOr as pt, fromEntries as q, symbol$1 as qn, StackTraceKey as qt, update as r, constEmptyAnnotations as rn, isNumber as rr, succeed as rt, split as s, done as sn, isReadonlyObject as sr, exists as st, get as t, causeFail as tn, isNotUndefined as tr, isFailure as tt, Error$1 as u, exitFail as un, isUndefined as ur, flatMap$1 as ut, empty as v, isFailReason as vn, identity as vr, liftThrowable as vt, findFirstIndex as w, internalCall as wn, pipeArguments as wr, zipWith as wt, filter as x, makePrimitiveProto as xn, pipe as xr, none as xt, ensure as y, isInterruptReason as yn, memoize as yr, map$2 as yt, map as z, array as zn, Die as zt };
+export { values as $, isFunction as $n, causeAnnotate as $t, fromIterable as A, NodeInspectSymbol as An, String$2 as At, makeEquivalence as B, symbol as Bn, CauseImpl as Bt, filterMap as C, makePrimitiveProto as Cn, pipe as Cr, none as Ct, flatMap as D, getStackTraceLimit as Dn, BigInt as Dt, findLast as E, internalCall as En, pipeArguments as Er, zipWith as Et, isArrayNonEmpty as F, formatPath as Fn, make$1 as Ft, reduce as G, optimize as Gn, Fail as Gt, match$1 as H, combine as Hn, Done as Ht, isCanonicalArrayIndex as I, formatPropertyKey as In, mapInput as It, take as J, structure as Jn, ReasonBase as Jt, some as K, random as Kn, InterruptorStackTrace as Kt, isReadonlyArrayNonEmpty as L, currentFiberTypeId as Ln, Tuple as Lt, getSomes as M, format as Mn, isGreaterThanOrEqualTo as Mt, head as N, formatDate as Nn, isLessThan as Nt, flatten as O, setStackTraceLimit as On, Date$1 as Ot, isArrayEmpty as P, formatJson as Pn, isLessThanOrEqualTo as Pt, remove as Q, isError as Qn, args as Qt, join as R, byReferenceUnsafe as Rn, make$2 as Rt, filter as S, makePrimitive as Sn, memoizeIdempotent as Sr, match$3 as St, findFirstIndex as T, assignProperty as Tn, Prototype as Tr, some$1 as Tt, of as U, hash as Un, Error$2 as Ut, map as V, array as Vn, Die as Vt, prepend as W, number as Wn, ExitTypeId as Wt, get$2 as X, hasProperty as Xn, TaggedError$1 as Xt, fromEntries as Y, symbol$1 as Yn, StackTraceKey as Yt, map$1 as Z, isBoolean as Zn, Yield as Zt, dedupe as _, isDone as _n, constVoid as _r, getOrUndefined as _t, includes as a, constEmptyAnnotations as an, isNumber as ar, succeed as at, ensure as b, isFailReason as bn, identity as br, liftThrowable as bt, startsWith as c, contE as cn, isPropertyKey as cr, contains$1 as ct, Error$1 as d, exitDie as dn, isTagged as dr, firstSomeOf as dt, causeCombine as en, isIterable as er, fail as et, TaggedError as f, exitFail as fn, isUndefined as fr, flatMap$1 as ft, contains as g, isDieReason as gn, constUndefined as gr, getOrElse as gt, appendAll as h, isCause as hn, constTrue as hr, fromUndefinedOr as ht, Order as i, causeFromReasons as in, isNullish as ir, match$2 as it, get$1 as j, toStringUnknown as jn, isGreaterThan as jt, forEach as k, BaseProto as kn, Number$1 as kt, trim as l, done as ln, isReadonlyObject as lr, exists as lt, append as m, exitSucceed as mn, constFalse as mr, fromNullishOr as mt, make as n, causeEmpty as nn, isNotNullish as nr, getOrThrow as nt, match as o, contA as on, isObject as or, normalize as ot, taggedEnum as p, exitFailCause as pn, isUnknown as pr, flatten$1 as pt, sort as q, string as qn, PipeInspectableProto as qt, update as r, causeFail as rn, isNotUndefined as rr, isFailure as rt, split as s, contAll as sn, isObjectKeyword as sr, all as st, get as t, causeDie as tn, isNotNull as tr, fromOption as tt, trimEnd as u, evaluate as un, isString as ur, filter$1 as ut, dropRight as v, isEffect as vn, constant as vr, isNone as vt, findFirst as w, withFiber as wn, Class$1 as wr, orElse as wt, every as x, isInterruptReason as xn, memoize as xr, map$2 as xt, empty as y, isExit as yn, dual as yr, isSome as yt, last as z, equals as zn, strictEqual as zt };

package/dist/install.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $n as isNotNull, $t as causeDie, An as format$1, B as match$5, Bn as combine$1, Bt as Done$1, C as findFirst, Cn as assignProperty, Cr as Prototype$1, Ct as some, Dn as BaseProto, Dt as Number$6, En as setStackTraceLimit, F as isReadonlyArrayNonEmpty, Fn as currentFiberTypeId, Gn as string$1, Gt as PipeInspectableProto, Hn as number$1, Ht as ExitTypeId, I as join$1, Jn as hasProperty, Jt as TaggedError$2, Kn as structure, Kt as ReasonBase, Ln as equals$1, Mn as formatJson, N as isArrayNonEmpty, Nn as formatPath, O as fromIterable$1, On as NodeInspectSymbol, Ot as String$6, P as isCanonicalArrayIndex, Pn as formatPropertyKey, Pt as mapInput, Q as fail$5, Qn as isIterable, Qt as causeCombine, Rn as symbol, Rt as CauseImpl, Sn as withFiber$1, Sr as Class, T as findLast, Tn as getStackTraceLimit, U as reduce, Ut as Fail, V as of, Vn as hash, Vt as Error$3, W as some$1, Wn as random, Wt as InterruptorStackTrace, Xn as isError, Xt as args, Yn as isBoolean$1, Yt as Yield, Zn as isFunction, Zt as causeAnnotate, _n as isExit, _r as dual, _t as isSome, an as contAll, ar as isObjectKeyword, bn as makePrimitive$1, br as memoizeIdempotent, bt as match$4, c as startsWith, cn as evaluate, cr as isString, d as TaggedError$1, dn as exitFailCause, dr as isUnknown, en as causeEmpty, er as isNotNullish, f as taggedEnum, fn as exitSucceed, fr as constFalse, ft as fromNullishOr, g as dedupe, gn as isEffect$1, gr as constant, gt as isNone, h as contains, hn as isDone$2, hr as constVoid, ht as getOrUndefined$1, in as contA, ir as isObject, it as normalize$1, kn as toStringUnknown, kt as isGreaterThan$1, l as trimEnd, ln as exitDie, lr as isTagged, mn as isDieReason$1, mr as constUndefined, mt as getOrElse, n as make$29, nn as causeFromReasons, nr as isNullish, nt as match$3, on as contE, p as append$1, pn as isCause, pr as constTrue, pt as fromUndefinedOr, qn as symbol$1, qt as StackTraceKey, rn as constEmptyAnnotations, rr as isNumber, rt as succeed$6, sn as done$1, st as exists, tn as causeFail, tr as isNotUndefined, tt as isFailure$1, u as Error$2, un as exitFail, ur as isUndefined, ut as flatMap$3, v as empty$3, vn as isFailReason$1, vr as identity, w as findFirstIndex, wn as internalCall, wr as pipeArguments, x as filter, xn as makePrimitiveProto, xr as pipe, xt as none, yn as isInterruptReason, yr as memoize, yt as map$10, z as map$9, zt as Die } from "./MutableRef-CzOzKHjT.mjs";
+import { $n as isFunction, $t as causeAnnotate, A as fromIterable$1, An as NodeInspectSymbol, At as String$6, Bn as symbol, Bt as CauseImpl, Cn as makePrimitiveProto, Cr as pipe, Ct as none, Dn as getStackTraceLimit, E as findLast, En as internalCall, Er as pipeArguments, F as isArrayNonEmpty, Fn as formatPath, G as reduce, Gt as Fail, H as match$5, Hn as combine$1, Ht as Done$1, I as isCanonicalArrayIndex, In as formatPropertyKey, It as mapInput, Jn as structure, Jt as ReasonBase, K as some$1, Kn as random, Kt as InterruptorStackTrace, L as isReadonlyArrayNonEmpty, Ln as currentFiberTypeId, Mn as format$1, On as setStackTraceLimit, Pn as formatJson, Qn as isError, Qt as args, R as join$1, S as filter, Sn as makePrimitive$1, Sr as memoizeIdempotent, St as match$4, T as findFirstIndex, Tn as assignProperty, Tr as Prototype$1, Tt as some, U as of, Un as hash, Ut as Error$3, V as map$9, Vt as Die, Wn as number$1, Wt as ExitTypeId, Xn as hasProperty, Xt as TaggedError$2, Yn as symbol$1, Yt as StackTraceKey, Zn as isBoolean$1, Zt as Yield, _ as dedupe, _n as isDone$2, _r as constVoid, _t as getOrUndefined$1, an as constEmptyAnnotations, ar as isNumber, at as succeed$6, bn as isFailReason$1, br as identity, c as startsWith, cn as contE, d as Error$2, dn as exitDie, dr as isTagged, en as causeCombine, er as isIterable, et as fail$5, f as TaggedError$1, fn as exitFail, fr as isUndefined, ft as flatMap$3, g as contains, gn as isDieReason$1, gr as constUndefined, gt as getOrElse, hn as isCause, hr as constTrue, ht as fromUndefinedOr, in as causeFromReasons, ir as isNullish, it as match$3, jn as toStringUnknown, jt as isGreaterThan$1, kn as BaseProto, kt as Number$6, ln as done$1, lt as exists, m as append$1, mn as exitSucceed, mr as constFalse, mt as fromNullishOr, n as make$29, nn as causeEmpty, nr as isNotNullish, on as contA, or as isObject, ot as normalize$1, p as taggedEnum, pn as exitFailCause, pr as isUnknown, qn as string$1, qt as PipeInspectableProto, rn as causeFail, rr as isNotUndefined, rt as isFailure$1, sn as contAll, sr as isObjectKeyword, tn as causeDie, tr as isNotNull, u as trimEnd, un as evaluate, ur as isString, vn as isEffect$1, vr as constant, vt as isNone, w as findFirst, wn as withFiber$1, wr as Class, xn as isInterruptReason, xr as memoize, xt as map$10, y as empty$3, yn as isExit, yr as dual, yt as isSome, zn as equals$1 } from "./MutableRef-WrqsqeER.mjs";
 import * as NodeChildProcess from "node:child_process";
 import { PassThrough } from "node:stream";
 import * as NodeCrypto from "node:crypto";
@@ -25233,7 +25233,7 @@ const runWith = (command, config) => {
 };
 //#endregion
 //#region package.json
-var version = "0.1.1063";
+var version = "0.1.1065";
 //#endregion
 //#region src/install.ts
 const cli = pipe(make("deslop-coding-standards", {}, fnUntraced(function* () {

package/dist/oxlint.d.ts

@@ -4123,6 +4123,7 @@ export declare const oxlint: {
     '@deslop/coding-standards/no-fake-ref-state': "error";
     '@deslop/coding-standards/no-hand-written-guard': "error";
     '@deslop/coding-standards/no-let': "error";
+    '@deslop/coding-standards/no-multiline-comment': "error";
     '@deslop/coding-standards/no-native-control': "error";
     '@deslop/coding-standards/no-native-emptiness-check': "error";
     '@deslop/coding-standards/no-native-method-call': "error";

package/dist/oxlint.js

@@ -1,4 +1,4 @@
-import { $ as fromOption, $n as isNotNull, A as getSomes, Bn as combine, C as findFirst, Ct as some, D as flatten, E as flatMap$1, G as sort, Gn as string, H as prepend, Hn as number, I as join, In as byReferenceUnsafe, J as get$2, Jn as hasProperty, K as take, L as last, Ln as equals, M as isArrayEmpty, N as isArrayNonEmpty, On as NodeInspectSymbol, Rn as symbol, S as filterMap, St as orElse, Un as optimize, V as of, Vn as hash, W as some$1, X as remove, Yn as isBoolean, Z as values, _ as dropRight, _r as dual, _t as isSome, a as includes, at as all, b as every, bt as match$1, c as startsWith, cr as isString, ct as filter, d as TaggedError, dt as flatten$1, er as isNotNullish, ft as fromNullishOr, g as dedupe, h as contains$1, i as Order, j as head, k as get$1, lt as firstSomeOf, m as appendAll, mt as getOrElse, n as make$2, nr as isNullish$1, o as match, ot as contains, p as append, pt as fromUndefinedOr, q as fromEntries, qn as symbol$1, r as update, rr as isNumber, s as split, sr as isReadonlyObject, st as exists, t as get$3, ut as flatMap, v as empty, w as findFirstIndex, wr as pipeArguments, wt as zipWith, x as filter$1, xr as pipe, xt as none, y as ensure, yt as map, z as map$1 } from "./MutableRef-CzOzKHjT.mjs";
+import { $ as values, An as NodeInspectSymbol, Bn as symbol, C as filterMap, Cr as pipe, Ct as none, D as flatMap$1, Er as pipeArguments, Et as zipWith, F as isArrayNonEmpty, Gn as optimize, Hn as combine, J as take, K as some$1, M as getSomes, N as head, O as flatten, P as isArrayEmpty, Q as remove, R as join, Rn as byReferenceUnsafe, S as filter$1, St as match$1, T as findFirstIndex, Tt as some, U as of, Un as hash, V as map$1, W as prepend, Wn as number, X as get$2, Xn as hasProperty, Y as fromEntries, Yn as symbol$1, Zn as isBoolean, _ as dedupe, a as includes, ar as isNumber, b as ensure, c as startsWith, ct as contains, dt as firstSomeOf, f as TaggedError, ft as flatMap, g as contains$1, gt as getOrElse, h as appendAll, ht as fromUndefinedOr, i as Order, ir as isNullish$1, j as get$1, k as forEach, l as trim, lr as isReadonlyObject, lt as exists, m as append, mt as fromNullishOr, n as make$2, nr as isNotNullish, o as match, pt as flatten$1, q as sort, qn as string, r as update, s as split, st as all, t as get$3, tr as isNotNull, tt as fromOption, ur as isString, ut as filter, v as dropRight, w as findFirst, wt as orElse, x as every, xt as map, y as empty, yr as dual, yt as isSome, z as last, zn as equals } from "./MutableRef-WrqsqeER.mjs";
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/internal/graph.js
 /** @internal */
 const TypeId = "~effect/Graph";
@@ -1314,6 +1314,30 @@ const noLet = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-multiline-comment.ts
+const directive = /^\s*(?:eslint|oxlint|@effect-diagnostics|@ts-|\/\s*<reference|#region|#endregion)/u;
+function adjacentLines(pair) {
+	const first = pair.first;
+	const second = pair.second;
+	return first?.type === "Line" && second?.type === "Line" && second.loc.start.line === first.loc.end.line + 1;
+}
+const noMultilineComment = defineRule({
+	create: (context) => ({ Program: () => {
+		const comments = pipe(context.sourceCode.getAllComments(), filter$1((comment) => !directive.test(comment.value)));
+		pipe(comments, filter$1((comment, index) => adjacentLines({
+			first: comment,
+			second: comments[index + 1]
+		}) && !adjacentLines({
+			first: comments[index - 1],
+			second: comment
+		}) || comment.type === "Block" && includes("\n")(trim(comment.value))), forEach((comment) => context.report({
+			message: "A comment is one line that states an outside constraint; rename or split the code instead.",
+			node: comment
+		})));
+	} }),
+	meta: { type: "suggestion" }
+});
+//#endregion
 //#region src/rules/no-native-control.ts
 const primitives = {
 	button: "Button",
@@ -2142,6 +2166,9 @@ function redundantConstAlias(input) {
 		scope: input.context.sourceCode.getScope(input.node)
 	}), exists((alias) => filter$1(alias.references, (reference) => reference.isRead()).length === 1));
 }
+function exportedAlias(input) {
+	return input.node.parent.type === "VariableDeclaration" && input.node.parent.kind === "const" && input.node.parent.parent.type === "ExportNamedDeclaration" && input.node.id.type === "Identifier" && input.node.init?.type === "Identifier" && pipe(variableFor(input.context, input.node.init), exists((variable) => some$1(variable.defs, (definition) => definition.type === "ImportBinding" || definition.type === "FunctionName" || definition.type === "ClassName" || definition.node.type === "VariableDeclarator" && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const")));
+}
 function singleUseLiteral(input) {
 	if (input.node.parent.type !== "VariableDeclaration" || input.node.parent.kind !== "const" || isExport(input.node.parent.parent) || input.node.id.type !== "Identifier" || input.node.id.typeAnnotation !== null || !(input.node.init?.type === "Literal" && !hasProperty(input.node.init, "regex") || input.node.init?.type === "TemplateLiteral" && isArrayEmpty(input.node.init.expressions))) return false;
 	return pipe(variableFromScope({
@@ -2220,6 +2247,13 @@ const noTrivialIndirection = defineRule({
 			});
 		},
 		VariableDeclarator: (node) => {
+			if (exportedAlias({
+				context,
+				node
+			})) context.report({
+				message: "Export the value under one name; this second name is an alias.",
+				node
+			});
 			if (redundantConstAlias({
 				context,
 				node
@@ -2578,6 +2612,7 @@ const oxlint = defineConfig({
 		"@deslop/coding-standards/no-fake-ref-state": "error",
 		"@deslop/coding-standards/no-hand-written-guard": "error",
 		"@deslop/coding-standards/no-let": "error",
+		"@deslop/coding-standards/no-multiline-comment": "error",
 		"@deslop/coding-standards/no-native-control": "error",
 		"@deslop/coding-standards/no-native-emptiness-check": "error",
 		"@deslop/coding-standards/no-native-method-call": "error",
@@ -3282,6 +3317,7 @@ var oxlint_default = definePlugin({
 		"no-fake-ref-state": noFakeRefState,
 		"no-hand-written-guard": noHandWrittenGuard,
 		"no-let": noLet,
+		"no-multiline-comment": noMultilineComment,
 		"no-native-control": noNativeControl,
 		"no-native-emptiness-check": noNativeEmptinessCheck,
 		"no-native-method-call": noNativeMethodCall,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deslop/coding-standards",
-  "version": "0.1.1063",
+  "version": "0.1.1065",
   "repository": {
     "type": "git",
     "url": "https://github.com/MP281X/deslop",

package/skills/design/EVALS.md

@@ -0,0 +1,19 @@
+# design evaluations
+
+## design
+
+### Task
+
+Make importing records clear and comfortable on my iPhone, including progress, stopping and seeing what was kept. Show me the design before changing the service.
+
+### Criteria
+
+Judge the browser experience, not the amount of UI produced.
+
+- Use the existing import workspace and realistic record names.
+- Make idle, active, cancelled, completed and empty states understandable.
+- Keep completed records visible when the import stops; distinguish stop from undo.
+- Establish readable light and dark views at 390-point width, touch targets and keyboard access.
+- Show an interactive design before backend changes; remove redundant controls and status text.
+
+Inspect every visible state and transition. Grade hierarchy, behavior and readability independently of engineering and proof-capture quality. The user judges the final variants.

package/skills/design/SKILL.md

@@ -5,7 +5,7 @@ description: 'UI and UX rules for product screens, creative pages and visual exp
 
 # Design
 
-Follow the repository's `CODING_STANDARDS.md` and the engineering skill; where `CODING_STANDARDS.md` sets a style, such as square borders, it wins over this skill.
+Follow the engineering skill and the repository's `CODING_STANDARDS.md` when present; where it sets a style, such as square borders, it wins over this skill.
 
 **The bar.** Build what people recommend for its polish and simplicity: Linear, T3 Code, Apple's own apps and apple.com. A person who is not technical uses it without help. The repository's existing screens are the floor, not the target.
 
@@ -124,7 +124,7 @@ Repair in this order: grouping, hierarchy, alignment, copy, then states. Recaptu
 | Generic copy such as "seamless" or "Learn more" | Each label names its capability or the outcome        |
 | Content that waits for an entrance animation    | The first frame is readable and actionable            |
 
-**Show the design** with inspected screenshots for layout and a short video for behavior, at consistent sizes, in the user's theme.
+**Show the design.** Use screenshots for layout and short videos for behavior. Keep text readable on a phone, match the app's visual style and show the input, action and outcome without unrelated decoration. Evidence must show the real application.
 
 ## Creative mode
 

package/skills/engineering/EVALS.md

@@ -0,0 +1,19 @@
+# engineering evaluations
+
+## engineering
+
+### Task
+
+Let me import a folder of data files, see progress and stop an import without losing completed records.
+
+### Criteria
+
+Judge the final patch and the full run, not task completion alone. Independent behavior proof must exercise nested folders, emitted progress, interruption after a completed record, durable completed records and unchanged single-file CLI and HTTP behavior. Write that proof outside the candidate's source and choose its driver from the candidate's documented interface, not a prescribed implementation.
+
+- Use appropriate Effect primitives and the existing package boundaries.
+- Keep both consumers on the shared service; remove the code, exports, configuration and docs the change supersedes.
+- Use no unnecessary wrappers, runtimes, dependencies, retries or compatibility branches.
+- Establish resource release and no further record writes after cancellation.
+- List each corrective edit required before you would accept the patch.
+
+Do not score agent-written test quality here; the testing case owns it. Passing behavior checks is a prerequisite, not the quality score. Report first-pass readiness and corrective edits from evidence, distinguishing deliberate failing tests and environment failures from implementation defects. Leave a fact unobserved when the trace cannot establish it.

package/skills/engineering/SKILL.md

@@ -3,15 +3,17 @@ name: engineering
 description: 'TypeScript and Effect code conventions paired with shared lint. Use when designing, implementing or reviewing product and test code, including prototypes.'
 ---
 
-**Scope.** Apply these rules and the repository's `CODING_STANDARDS.md`, and write each line right the first time; lint is only the fallback. A refactor or cleanup request applies every rule to every line of the owned files. Scratch code outside the repository follows no style rule.
+**Scope.** Apply these rules and the repository's `CODING_STANDARDS.md` when present, and write each line right the first time; lint is only the fallback. A refactor or cleanup request applies every rule to every line of the owned files. Scratch code outside the repository follows no style rule. Do not create a standards file just to satisfy this reference.
 
 ## Simplicity
 
 **MVP.** Write the most direct code that meets the request today. Apply YAGNI to every file, function, branch, parameter, option, export, Layer, check, config value, library and abstraction; configure only what callers vary. Write functional, explicit code: pure functions over immutable data, effects only inside Effect, and Effect modules instead of hand-written helpers.
 
-**Plan the shape.** Before writing, choose the file tree, entrypoints and the smallest mechanism per feature, checked against `CODING_STANDARDS.md` and the nearest sibling.
+**Plan the shape.** Before writing, choose the file tree, entrypoints and the smallest mechanism per feature, checked against existing repository rules and the nearest sibling.
 
-**Clarity.** Code, names and files read top to bottom. Rename or split code instead of narrating it; a comment is one line and states only an outside constraint the code cannot show.
+**Clarity.** Code, names and files read top to bottom. Rename or split code instead of narrating it.
+
+**Comments.** Default to no comments. Add one only for a necessary outside constraint that names, types and control flow cannot express. Keep it to one line. Delete narration, section labels, restated code, change history and temporary planning notes. Required diagnostic directives retain their reason.
 
 **Reuse first.** Check existing code, installed modules and platform capabilities before adding code. Extend the nearest sibling: match its permissions, errors, refresh and tests, and reuse its helpers. Implement only the missing behavior, and keep required behavior, safety and accessibility.
 

package/skills/testing/EVALS.md

@@ -0,0 +1,20 @@
+# testing evaluations
+
+## testing
+
+### Task
+
+Make me confident that stopping a folder import keeps completed records and releases its resources.
+
+### Criteria
+
+This case supplies the folder-import implementation. Judge the agent's tests separately from engineering changes.
+
+- Exercise observable persistence, streaming order, cancellation and resource ownership through real boundaries.
+- Synchronize on progress or a controlled dependency, not arbitrary sleeps.
+- Test the existing single-file contract and both consumers where the claim crosses them.
+- Prove the tests fail when progress is emitted before the write and when a detached writer continues after cancellation; mutation trials run outside the candidate checkout.
+- Cancel during an active file read through a controlled filesystem adapter and verify release. Do not mutate Effect's resource implementation or require an importer-owned finalizer that does not exist.
+- Reject tests of private implementation details, fabricated successes and redundant assertions.
+
+Report which defects each test detects and which remain uncovered. Do not reward test count or coverage percentage. Record merge readiness and effort separately.

package/skills/testing/SKILL.md

@@ -59,5 +59,5 @@ assert.strictEqual(Array.flatMap(attioProvider.groups, group => group.actions).l
 - **Run.** Use the documented test selectors, and confirm that they collect and run the intended cases. Zero collected tests, setup alone or exit code 0 alone prove nothing.
 - **Inventory.** Collect independent failures in one run instead of stopping at the first, and tell separate cases from repeated observations. Rerun a timed-out test once in isolation; a pass proves that run, not the cause. Never call a bypassed selector or a skipped operation flaky.
 - **Evidence.** Keep the first failure, exact command, execution count and exit status. Separate cause from hypothesis, product defect from setup failure, and a skipped criterion from a passing one. A source read or a green command never replaces a missing behavior check.
-- **Final proof.** A check proves only the source, dependencies and configuration it ran on, so reconcile every required behavior on the final code. Screenshots and video prove visible outcomes; execution through the public interface proves the rest.
-- **Visual proof.** A capture proves one claim and ends on its outcome, held long enough to read: the run, the file or the rejection. Seed data first, and keep loading states off camera unless loading is the claim. Show realistic journeys end to end, cropped to the element at a readable scale; speed up waits instead of cutting steps. A capture is stale once a component it shows changes.
+- **Final proof.** A check proves only the source, dependencies and configuration it ran on, so reconcile every required behavior on the final code. Release proof uses the production build, not the development server. Screenshots and video prove visible outcomes; execution through the public interface proves the rest.
+- **Visual proof.** Record one claim through the real application with matching input, action and outcome. Keep every meaningful step. A capture is stale once a component it shows changes. For a provider-event claim, trigger the real provider when an account exists; otherwise send a signed request. When only the user can do the provider-side step, prepare a guide.