Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
26 commits
Select commit Hold shift + click to select a range
a8b50d6
Replace legacy icons with Vuesax and refresh web UI (#144)
prem315 Nov 7, 2026
7f7c028
Add comprehensive settings sections and MCP configuration (#145)
prem315 Nov 7, 2026
4f68789
fix(harness): derive resumable runs from log positions (#146)
sanchitrk Nov 8, 2026
3cab529
fix(harness): harden durable runs after the head/tail review (#147)
sanchitrk Nov 9, 2026
1f4b876
fix(harness): count a crash before the request as a failed attempt (#…
sanchitrk Nov 10, 2026
a8199d0
fix(harness): record a stop before interrupting, derive recovery in t…
sanchitrk Nov 10, 2026
d49b43a
feat(web): sidebar grouping, Linear-like thread statuses, dense menus…
prem315 Nov 10, 2026
fe449e0
feat(web): frame menu, sidebar current and color, project settings wi…
sanchitrk Nov 11, 2026
d46f92c
test(codework): regenerate the mcpcli artifact for formatted removals…
sanchitrk Nov 11, 2026
bf1276e
feat: pick a model from configured providers; stack queued prompts be…
sanchitrk Nov 11, 2026
34351ed
fix(web): show a new session's first prompt; cheaper streaming render…
sanchitrk Nov 11, 2026
c05d48e
docs: note the model pick, queued-prompt stack and composer fix under…
sanchitrk Nov 11, 2026
c8ed8c5
feat: project settings MCP and Skills; fix app server tests (#155)
sanchitrk Nov 13, 2026
81a1eb9
feat: space daemon plugins with git and skills daemons (#156)
sanchitrk Nov 13, 2026
50ef80e
chore(server): name the daemon mirror table machine_space_state (#157)
sanchitrk Nov 13, 2026
188b009
feat(desktop): keep app.db in the CodeWork home under desktop/<channe…
sanchitrk Nov 13, 2026
6122bd6
fix(desktop): name a repo run CodeWork Local and give each build its …
sanchitrk Nov 13, 2026
45a0e02
feat: Git Changes widget for a space's working tree (#160)
sanchitrk Nov 13, 2026
42fbdd0
refactor(desktop): replace vuesax icons with Phosphor (#161)
sanchitrk Nov 13, 2026
52308ba
feat(desktop): slide the sidebar and refine Phosphor icons (#162)
sanchitrk Nov 13, 2026
285b733
fix(desktop): space the title bar controls from the workspace tabs (#…
sanchitrk Nov 13, 2026
1bf8385
fix(desktop): polish the sidebar, close crosses and empty-state copy …
sanchitrk Nov 13, 2026
6482470
feat: metrics page backed by a durable usage rollup (#165)
sanchitrk Nov 14, 2026
0c0579e
fix: re-read the index from zero when the store left its boot line (#…
sanchitrk Nov 14, 2026
b9173fe
test(server): seed the metrics simulation from a fixed until (#168)
sanchitrk Nov 14, 2026
51a2e58
refactor(desktop): rename workspaces to tabs
sanchitrk Nov 15, 2026
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
The table of contents is too big for display.
Diff view
Diff view
  •  
  •  
  •  
385 changes: 385 additions & 0 deletions .agents/skills/animate-expo/RECIPES.md

Large diffs are not rendered by default.

263 changes: 263 additions & 0 deletions .agents/skills/animate-expo/SKILL.md

Large diffs are not rendered by default.

292 changes: 292 additions & 0 deletions .agents/skills/choreograph/RECIPES.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,292 @@
# Choreography Recipes

Copy-ready patterns for the relationships in [SKILL.md](SKILL.md). The values are starting points, so tune them on a recording.

## Overlap: CSS stagger with an index variable

For one-shot entrances (a hero, a personal site intro). The delay is computed per element from a custom property, so you don't need one class per item.

```tsx
<div className="stagger">
<h1 style={{ "--i": 0 }}>Title</h1>
<p style={{ "--i": 0 }}>First paragraph, same beat as the title</p>
<p style={{ "--i": 1 }}>Supporting paragraph</p>
<div style={{ "--i": 2 }}>CTAs</div>
</div>
```

```css
.stagger > * {
--step: 120ms;
animation: enter 0.6s ease both;
animation-delay: calc(var(--step) * var(--i));
}

@keyframes enter {
from {
opacity: 0;
transform: translateY(10px);
}
}

@media (prefers-reduced-motion: reduce) {
.stagger > * {
animation-name: fade;
animation-delay: 0ms;
}
@keyframes fade {
from { opacity: 0; }
}
}
```

- `both` is required. `backwards` applies the first keyframe during the delay, so later items don't flash their final state before they animate. `forwards` keeps the end state.
- Omitting `to` makes the keyframe animate to the element's own styles.
- Changing a custom property on a parent recalculates styles for every descendant. That's fine for a one-shot entrance, but don't drive per-frame values (a drag) through an inherited variable on a large tree.

## Overlap: Motion variants with a non-uniform stagger

```tsx
import { motion, stagger } from "motion/react";

const list = {
hidden: {},
show: {
transition: {
// Delays shrink as the group goes on, so it reads as a wave, not a metronome
delayChildren: stagger(0.06, { ease: "easeOut" }),
},
},
};

const lead = {
hidden: { opacity: 0, y: 12 },
show: { opacity: 1, y: 0, transition: { duration: 0.5, ease: [0.23, 1, 0.32, 1] } },
};

const support = {
hidden: { opacity: 0, y: 6 },
show: { opacity: 1, y: 0, transition: { duration: 0.4, ease: [0.23, 1, 0.32, 1] } },
};

const decoration = {
hidden: { opacity: 0 },
show: { opacity: 1, transition: { duration: 0.3 } },
};

<motion.section variants={list} initial="hidden" animate="show">
<motion.span variants={decoration}>New</motion.span>
<motion.h1 variants={lead}>Title</motion.h1>
<motion.p variants={support}>Subtitle</motion.p>
<motion.div variants={support}>CTAs</motion.div>
</motion.section>
```

- Each role gets its own variant (distance, duration). The stagger only sets *when* each one starts.
- `stagger(0.05, { from: "center" })` radiates out from the middle. Use a number index to radiate from the item the user interacted with.
- Older Motion versions use `staggerChildren: 0.06` instead of `delayChildren: stagger(...)`.
- For long lists, give items beyond the first ~6 the same delay as the 6th, so the group never takes longer than ~300ms.

## Together: remove the exiting element from the flow

Siblings close the gap *while* the removed item fades, not after.

```tsx
<ul>
<AnimatePresence mode="popLayout" initial={false}>
{chips.map((chip) => (
<motion.li
key={chip.id}
layout
exit={{ opacity: 0, scale: 0.95 }}
transition={{ duration: 0.2, ease: [0.23, 1, 0.32, 1] }}
>
{chip.label}
</motion.li>
))}
</AnimatePresence>
</ul>
```

Without a library: before running the exit, read the element's offset, set `position: absolute` with that `top`/`left` on it (the parent needs `position: relative`), then animate it out. Animate the siblings with FLIP or let them reflow.

## Together: crossfade views in a resizing container

The container's height and the content swap are one object: same duration, same easing family.

```tsx
import useMeasure from "react-use-measure";

const [ref, bounds] = useMeasure();
const prevHeight = useRef<number>();

// The fade duration scales with how far the container moves
const fadeDuration = useMemo(() => {
const MIN = 0.15;
const MAX = 0.27;
if (!prevHeight.current) {
prevHeight.current = bounds.height;
return MIN;
}
const delta = Math.abs(bounds.height - prevHeight.current);
prevHeight.current = bounds.height;
return Math.min(Math.max(delta / 500, MIN), MAX);
}, [bounds.height]);

<motion.div
animate={{ height: bounds.height }}
transition={{ duration: 0.27, ease: [0.25, 1, 0.5, 1] }}
style={{ overflow: "hidden" }}
>
<div ref={ref}>
<AnimatePresence initial={false} mode="popLayout">
<motion.div
key={view}
initial={{ opacity: 0, scale: 0.96 }}
animate={{ opacity: 1, scale: 1 }}
exit={{ opacity: 0, scale: 0.96 }}
transition={{ duration: fadeDuration, ease: [0.26, 0.08, 0.25, 1] }}
>
{content}
</motion.div>
</AnimatePresence>
</div>
</motion.div>
```

- The height uses a strong `ease-out`, and the content uses a lighter curve from the same family, so the swap stays visible without falling out of sync.
- `key` on the child is what tells `AnimatePresence` a view left. A missing key is the first thing to check when an exit doesn't play.
- If the container is part of a larger component (a drawer), bring that component's own open duration in line with this one so the whole thing feels like one entity.

## Direction-aware steps

```tsx
const [[step, direction], setStep] = useState([0, 0]);
const go = (d: 1 | -1) => setStep(([s]) => [s + d, d]);

const variants = {
initial: (d: number) => ({ x: `${110 * d}%`, opacity: 0 }),
active: { x: "0%", opacity: 1 },
exit: (d: number) => ({ x: `${-110 * d}%`, opacity: 0 }),
};

<MotionConfig transition={{ type: "spring", duration: 0.5, bounce: 0 }}>
<AnimatePresence mode="popLayout" initial={false} custom={direction}>
<motion.div
key={step}
custom={direction}
variants={variants}
initial="initial"
animate="active"
exit="exit"
>
{content}
</motion.div>
</AnimatePresence>
<motion.div layout>{/* Back / Continue follow the height change */}</motion.div>
</MotionConfig>
```

`custom` goes on **both** `AnimatePresence` and the child. The exiting child reads the latest direction from `AnimatePresence`. Without that, it uses the direction it had when it mounted.

For small containers or similar views, swap the 110% slide for a crossfade with an 8px shift and a light blur. The eyes barely move and the change still reads.

## Sequence: one draw after another

```css
.square {
animation: draw 0.6s cubic-bezier(0.645, 0.045, 0.355, 1) forwards;
}

.checkmark {
animation: draw 0.4s cubic-bezier(0.645, 0.045, 0.355, 1) forwards;
animation-delay: 0.6s; /* = the square's duration */
}

@keyframes draw {
to { stroke-dashoffset: 0; }
}
```

With `pathLength="100"` on both paths, `stroke-dasharray: 100; stroke-dashoffset: 100` hides each one with round numbers. To make the handoff read as one gesture, start the checkmark slightly before the square finishes (e.g. 0.5s).

## Sequence: morph between two rich states with a crossfade

`mode="wait"` is the safe default when a container changes width *and* height between dense views. To keep a crossfade anyway:

1. Render the active view twice. Copy A animates only the **enter**. Copy B is `position: absolute`, sits at `opacity: 0`, and only becomes visible while **exiting**: its exit is a keyframe that starts at `opacity: 1` and fades out.
2. Give the exiting copy its own transform depending on where the container is going. Scale it up if the next state is larger and down if it's smaller, with `scaleX` pulling it toward the center when the container narrows so it doesn't bleed out of the edges.
3. With a handful of states, hardcode these values (and the spring bounce) per state pair, and pass them through `custom`. Smaller states get more bounce.

## Carry: steer a shared layout animation through its parent

You can't customize the path a `layoutId` animation takes, but you can move the container it lands in.

```tsx
<motion.div
animate={{ y: 73 }}
transition={{ delay: 0.13, duration: 0.3, ease: [0.23, 1, 0.32, 1] }}
>
{selected.map((img) => (
<motion.img key={img.id} layoutId={img.id} src={img.src} />
))}
</motion.div>
```

The images morph into the bin *and* drop with it. Show the bin's front face with a delay timed to when the images have almost landed, so they never visibly pass through it.

## Imperative orchestration (`useAnimate`)

Use this only when several elements coordinate across several events and you need to await completion.

```tsx
const [scope, animate] = useAnimate();
const running = useRef<ReturnType<typeof animate>[]>([]);
const ready = useRef(false); // a flag that never renders, so no useState

function play(steps: ReturnType<typeof animate>[]) {
running.current.forEach((a) => a.stop()); // never stack sequences
running.current = steps;
return Promise.all(steps);
}

const onEnter = async () => {
ready.current = false;
await play([
animate("[data-animate='icon']", { y: -4 }, { duration: 0.3 }),
...[...scope.current.querySelectorAll("[data-animate='line']")].map((el, i) =>
animate(
el,
{ strokeDashoffset: [1.05, 0] },
{ duration: 0.5, times: [0.7, 0.9], delay: i === 1 ? 0 : 0.04 },
),
),
]);
ready.current = true;
};

const onClick = () => {
if (!ready.current) return;
// A repeat action skips the buildup: the same proportions, earlier in the timeline
play([animate("[data-animate='bg']", { scale: [1, 0.96, 1.02, 1] }, { duration: 0.4 })]);
};

const onLeave = async () => {
await play([/* reset every element */]);
startIdle(); // only once the reset has finished
};

function startIdle() {
// Tracked in `running`, so the next onEnter stops the loop
running.current = [
animate("[data-animate='icon']", { y: [0, -3, 0] }, {
delay: 2.5,
repeat: Infinity,
repeatDelay: 6,
}),
];
}
```

- Target elements with `data-animate` selectors inside `scope` instead of keeping a ref per element.
- Await `Promise.all` when the durations differ. Awaiting just one animation is only safe when they all share a duration.
Loading