# Calls Desk

> A generator produces clips of a fixed maximum length, so a shot longer than the cap is not one
> call. Six shots at 8, 6, 18, 10, 9 and 3 seconds read as six things to generate; on a five-second
> generator they are THIRTEEN CALLS WITH SEVEN SEAMS. Nothing about the plan is wrong - it is
> arithmetic nobody did. Five lanes over one profile-and-shots sheet, plus a free browser-side call
> decomposition and waste ledger.

URL: https://calls-desk.skillsafe.ai/
API: https://calls-desk.skillsafe.ai/api.html

Derived from netease-youdao/lobsterai (https://github.com/netease-youdao/lobsterai), MIT: its
seedance skill, which drives a video generator over text-to-video, image-to-video and audio-synced
modes. Not affiliated with or endorsed by netease-youdao.

## The arithmetic

```text
calls  = ceil(seconds / cap)
seams  = calls - 1
billed = sum over calls of max(call_seconds, floor)
waste  = billed - delivered
```

None of those four numbers appears in a shot list and all four are forced by it. The same six shots
on a twenty-second generator are six calls and no seams.

## Splitting: the count is forced, the distribution is not

```text
12s at a 5s cap, filled greedily :  5 + 5 + 2
12s at a 5s cap, balanced        :  4 + 4 + 4
```

Same three calls, same bill. One is two long clips and a stub; the other cuts. When the remainder is
smaller still the stub is unusable outright - under 1.5s it is too short to hold on and too long to
hide in a transition, so it gets discarded and regenerated. Balancing removes it for free. Always
report the balanced split and show the greedy one beside it when they differ.

## What a seam costs

Every seam is a join between two independent generations, and the model has no memory across a call
boundary. A shot in four calls is three chances to see the cut. The arithmetic decides how many; the
ACTION decides where - a seam on a whip pan or a light change costs nothing, a seam in a held
gesture is the one everybody sees.

## Billed against delivered

Generated seconds are billed; delivered seconds are used. A three-second logo against a four-second
minimum call bills four and uses three. One is nothing, six across a film is real money, and per
shot it is invisible - it exists only in the total.

## Two things this will not invent

- THE PROFILE. Built-in profiles are a snapshot written down on a stated date, not a live lookup.
  Limits move. Your own numbers win outright; a model not in the snapshot inherits nothing.
- THE RETRY RATE. The call count assumes every generation is kept, which nobody does, so it is a
  FLOOR rather than an estimate. Supply your own attempts-per-accepted figure and it becomes one.

## A property worth knowing

Duration reductions are worth nothing until they cross a multiple of the cap, and then they are
worth a whole call. Two seconds off an 18s shot at an 8s cap saves an entire call; two seconds off
an 8s shot at the same cap saves nothing. A trim is never a proportional saving.

## The sheet

```text
PROFILE
model  | generic-5s
cap    | 5
floor  | 0
ratios | 16:9, 9:16
modes  | t2v, i2v
audio  | no
price  | 0.40

SHOTS
s01 | 12 | mode=i2v | ratio=16:9 | the courier crosses the road
```

Any PROFILE field overrides the preset above it. A shot's duration is the bare number after the id.

## The lanes

Modes: `t2v` text-to-video, `i2v` image-to-video, `flf` first-and-last-frame, `ref` reference image.

## The lanes

- `plan` - turns a film and a generator into a shot list sized to the cap
- `check` - says what an existing plan really costs in calls and seams
- `split` - chooses where a long shot cuts, on the action rather than the arithmetic midpoint
- `profile` - turns provider documentation into a profile, marking every field it had to guess
- `budget` - the bill, and which single change takes the most off it

## What it does not do

It calls no provider and generates nothing. It does arithmetic on numbers you supply, so it is only
as good as the profile you give it.