@gentbajko/slopify 3.0.4 → 3.0.5

package/dist/edge/http/projects.js

@@ -7,6 +7,7 @@ import { defaultChannelId } from "../../slices/channels/model.js";
 import { projectChannels } from "../../slices/channels/repo.js";
 import { withProjectControl } from "../../slices/control/lock.js";
 import { stagesWithEta } from "../../slices/eta/view.js";
+import { videoActivity } from "../../slices/rebuild/activity.js";
 import { resumable } from "../../slices/rebuild/recovery-repo.js";
 import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
@@ -90,7 +91,12 @@ export function projectRoutes(deps) {
             revisionId: currentRevisionId(deps.db, project.id) ?? null,
             resumable: resumable(deps.db, project.id),
             project: summarise(project),
-            stages: stagesWithEta(deps.db, stagesOf(deps.db, project.id), project.config, deps.clock.now()),
+            stages: stagesWithEta(deps.db, stagesOf(deps.db, project.id), project.config, deps.clock.now()).map((stage) => {
+                if (stage.kind !== "video" || stage.state !== "running")
+                    return stage;
+                const activity = videoActivity(deps.db, project.id);
+                return activity === undefined ? stage : { ...stage, activity };
+            }),
             outputs: outputsOf(deps.db, project.id),
         });
     })

package/dist/patch-notes/3.0.5.md

@@ -0,0 +1,30 @@
+# Slopify 3.0.5
+
+Released 28 September 2026.
+
+3.0.5 says what a running video is doing in plain words, adds a clock for how long Slopify worked on a project, and gives the browser extension Slopify's own icon.
+
+## Highlights
+
+- **Clear video progress**: "Rendering the video (82%)" instead of "10.159999999999998 of 50".
+- **A work clock** on every project: how long Slopify spent working, never the time spent waiting on you.
+- **Slopify's icon** in the browser extension.
+
+## Project page
+
+- A running Video stage names the step it is on and counts that step alone: "Timing the captions (30%)", "Drawing the shorts' pictures (12 of 38)", "Rendering the video (82%)". The count used to add every short's pictures and renders once the shorts were picked, so it jumped from 9 of 11 to 10 of 50 and the bar went backwards.
+- While a project runs, the top of its page shows **Working for 9 min 30 s**, ticking while a step runs. While it is paused or waits on a review or a plan limit, the clock holds still and reads "9 min 30 s of work so far".
+- When a run ends, the cost line adds how long it worked: "This run cost $2.73 · 22 min 15 s of work". Steps that run side by side, such as narration and images, count once.
+- The **Cost** section shows this run's working time, each stage's working time and the total over every run. The old "end to end" time was often wrong: it added up stages that ran at the same time.
+
+## Home
+
+- Running projects show whole numbers in their progress, never long decimals.
+
+## Browser extension
+
+- The toolbar button and the browser's extensions page show Slopify's icon, not a plain letter.
+
+## Upgrading from 3.0.4
+
+- **Nothing becomes outdated.** Past projects get their working time from the steps they already ran.

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.0.5",
+    "title": "Slopify 3.0.5",
+    "version": "3.0.5",
+    "date": "2026-09-28"
+  },
   {
     "id": "3.0.4",
     "title": "Slopify 3.0.4",

package/dist/slices/rebuild/activity.js

@@ -0,0 +1,58 @@
+import { currentRevisionId } from "../revisions/repo.js";
+function percentOf(row) {
+    if (row?.current === null || row?.total === null || row === undefined || !row.total)
+        return undefined;
+    return Math.max(0, Math.min(99, Math.floor((row.current / row.total) * 100)));
+}
+// The steps of a kind, done of all, while one of them runs.
+function counted(rows, match) {
+    const own = rows.filter((row) => match.test(row.key));
+    if (!own.some((row) => row.state === "running"))
+        return undefined;
+    return { done: own.filter((row) => row.state === "done").length, total: own.length };
+}
+export function videoActivity(db, projectId) {
+    const head = currentRevisionId(db, projectId);
+    if (head === undefined)
+        return undefined;
+    const rows = db
+        .prepare(`SELECT r.work_key AS key, w.state AS state, w.progress_current AS current, w.progress_total AS total
+       FROM revision_work_reservations r JOIN revision_work w ON w.id = r.work_id
+       WHERE r.revision_id = ? AND w.project_id = ? AND w.kind = 'video'`)
+        .all(head, projectId)
+        .map((row) => ({
+        key: String(row.key),
+        state: String(row.state),
+        current: typeof row.current === "number" ? row.current : null,
+        total: typeof row.total === "number" ? row.total : null,
+    }));
+    const running = (key) => rows.find((row) => row.key === key && row.state === "running");
+    const percent = (label, row) => {
+        const value = percentOf(row);
+        return value === undefined ? { label } : { label, percent: value };
+    };
+    if (running("export:video"))
+        return percent("rendering the video", running("export:video"));
+    if (running("export:wav"))
+        return percent("exporting the audio", running("export:wav"));
+    if (running("voices:files"))
+        return { label: "making the MP3 and M4B" };
+    const renders = counted(rows, /^shorts:\d+:render$/);
+    if (renders !== undefined)
+        return { label: "rendering the shorts", ...renders };
+    const pictures = counted(rows, /^shorts:\d+:image:\d+$/);
+    if (pictures !== undefined)
+        return { label: "drawing the shorts' pictures", ...pictures };
+    const prompts = counted(rows, /^shorts:\d+:prompts$/);
+    if (prompts !== undefined)
+        return { label: "planning the shorts' pictures", ...prompts };
+    if (running("shorts:pick"))
+        return { label: "picking the shorts" };
+    if (running("youtube:description"))
+        return { label: "writing the YouTube description" };
+    if (running("subtitles:timing"))
+        return percent("timing the captions", running("subtitles:timing"));
+    if (running("subtitles:cues") || running("subtitles:files"))
+        return { label: "writing the captions" };
+    return undefined;
+}

package/dist/slices/run-cost/panel.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { planAccountNames, planAccountOf, planAccounts, } from "../../kernel/ports/plan-limits.js";
+import { projectTiming } from "./timing.js";
 const usageRow = z.object({
     stage: z.enum(stageKinds),
     kind: z.enum(["llm", "tts", "image", "video"]),
@@ -59,12 +60,13 @@ function add(into, row) {
         seconds: into.seconds + (row.seconds ?? 0),
     };
 }
-export function runCostOf(db, projectId) {
+export function runCostOf(db, projectId, now = Date.now()) {
     const rows = db
         .prepare("SELECT stage, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, on_plan, cost, api_model, api_cost, price_json FROM provider_usage WHERE project_id = ? ORDER BY created_at, rowid")
         .all(projectId)
         .map((row) => usageRow.parse(row));
-    const walls = stageWalls(db, projectId);
+    const timing = projectTiming(db, projectId, now);
+    const walls = timing.byStage;
     const stages = new Map();
     const models = new Map();
     let total = { ...emptyLine, ...emptyTotals };
@@ -104,8 +106,9 @@ export function runCostOf(db, projectId) {
             characters: total.characters,
             images: total.images,
             seconds: total.seconds,
-            wallMs: [...walls.values()].reduce((sum, ms) => sum + ms, 0),
+            wallMs: timing.workingMs,
         },
+        run: timing.run,
         byStage: stageKinds.flatMap((kind) => {
             const found = stages.get(kind);
             return found === undefined ? [] : [found];
@@ -125,26 +128,6 @@ function catalogueOf(json) {
     const parsed = z.object({ catalogue: z.string() }).safeParse(JSON.parse(json));
     return parsed.success ? parsed.data.catalogue : null;
 }
-function stageWalls(db, projectId) {
-    const walls = new Map();
-    for (const raw of db
-        .prepare("SELECT kind, started_at, finished_at FROM stages WHERE project_id = ?")
-        .all(projectId)) {
-        const row = z
-            .object({
-            kind: z.enum(stageKinds),
-            started_at: z.string().nullable(),
-            finished_at: z.string().nullable(),
-        })
-            .parse(raw);
-        if (row.started_at === null || row.finished_at === null)
-            continue;
-        const ms = Date.parse(row.finished_at) - Date.parse(row.started_at);
-        if (Number.isFinite(ms) && ms >= 0)
-            walls.set(row.kind, ms);
-    }
-    return walls;
-}
 // Two readings belong to the same window when their resets agree to within a few minutes;
 // a reset moving on means the window rolled over between them.
 const sameWindowMs = 5 * 60_000;

package/dist/slices/run-cost/timing.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { currentRevisionId } from "../revisions/repo.js";
+const attemptRow = z.object({
+    kind: z.enum(stageKinds),
+    revision_id: z.string().nullable(),
+    started_at: z.string(),
+    ended_at: z.string().nullable(),
+    work_state: z.string().nullable(),
+});
+// The time any of the intervals covers.
+export function coveredMs(intervals) {
+    const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+    let total = 0;
+    let open;
+    for (const [start, end] of sorted) {
+        if (open === undefined || start > open[1]) {
+            if (open !== undefined)
+                total += open[1] - open[0];
+            open = [start, end];
+        }
+        else
+            open[1] = Math.max(open[1], end);
+    }
+    return open === undefined ? total : total + open[1] - open[0];
+}
+export function projectTiming(db, projectId, now) {
+    const rows = db
+        .prepare(`SELECT s.kind AS kind, a.revision_id AS revision_id, a.started_at AS started_at,
+         a.ended_at AS ended_at, w.state AS work_state
+       FROM attempts a JOIN stages s ON s.id = a.stage_id
+       LEFT JOIN revision_work w ON w.id = a.work_id
+       WHERE s.project_id = ?`)
+        .all(projectId)
+        .map((row) => attemptRow.parse(row));
+    const head = currentRevisionId(db, projectId);
+    const all = [];
+    const runs = new Map();
+    const stages = new Map();
+    for (const row of rows) {
+        const start = Date.parse(row.started_at);
+        if (!Number.isFinite(start))
+            continue;
+        // An attempt with no end is still running only while its step is; one a crash left open
+        // counts as nothing, so no clock ticks on forever.
+        const live = row.ended_at === null && row.work_state === "running";
+        const end = row.ended_at === null ? (live ? now : start) : Date.parse(row.ended_at);
+        if (!Number.isFinite(end) || end < start)
+            continue;
+        const interval = [start, end];
+        all.push(interval);
+        stages.set(row.kind, [...(stages.get(row.kind) ?? []), interval]);
+        if (row.revision_id !== null) {
+            const run = runs.get(row.revision_id) ?? { intervals: [], running: false, last: start };
+            run.intervals.push(interval);
+            run.running ||= live;
+            run.last = Math.max(run.last, start);
+            runs.set(row.revision_id, run);
+        }
+    }
+    const latest = (head === undefined ? undefined : runs.get(head)) ??
+        [...runs.values()].sort((a, b) => b.last - a.last)[0];
+    const byStage = new Map();
+    for (const [kind, intervals] of stages)
+        byStage.set(kind, coveredMs(intervals));
+    return {
+        run: latest === undefined
+            ? null
+            : runOf(latest.intervals, latest.running, latest === runs.get(head ?? "")),
+        workingMs: coveredMs(all),
+        byStage,
+    };
+}
+function runOf(intervals, running, current) {
+    return { current, running, workingMs: coveredMs(intervals) };
+}

package/dist/tutorials/Costs-and-Run-Cost.md

@@ -49,7 +49,7 @@ When a CLI's plan is used up, the run waits instead of failing: the status reads
 
 ## After a run: the run cost line
 
-When a run has ended, one line at the top of its project page, under the title, sums it up: for example `This run cost $0.42 · ~$3.10 via API · 12 min end to end`. A failed or cancelled run says **Spent so far**, and calls without a known price add "plus unpriced calls". **See cost by stage** opens the full breakdown below. The line doesn't show while the run is going, or when it spent nothing.
+When a run has ended, one line at the top of its project page, under the title, sums it up: for example `This run cost $0.42 · ~$3.10 via API · 12 min of work`. A failed or cancelled run says **Spent so far**, and calls without a known price add "plus unpriced calls". **See cost by stage** opens the full breakdown below. The line doesn't show while the run is going, or when it spent nothing.
 
 ## After a run: the Run cost tab
 
@@ -65,7 +65,7 @@ If nothing has been spent yet, it says "Nothing has been spent yet. The cost of
 | **paid to providers** | The total cost of this project's calls. Reads "known cost, paid to providers" when some calls have no price, with a line "Plus N calls the model catalogue has no price for." |
 | **same work via API** | The API equivalent of the calls that ran on a CLI plan. |
 | Plan meters | One per plan window a CLI reported, for example "3% of weekly Codex limit". Hover or read the line below for the level it is at now. |
-| **end to end** | How long the whole run took. |
+| **this run's working time** | How long some step of the run was working. Waiting on a review, a limit or a pause never counts, and steps that ran side by side count once. Each save that remakes something starts a new run. |
 
 Lines under the summary:
 
@@ -89,7 +89,7 @@ Lines under the summary:
 
 **Cost by model**: the same spending split by provider and model, with **Cost**, **Via API**, **Usage** and **Calls**. A CLI model shows the API model it was priced as, in brackets after "as". The CLI's own default model shows as "default model".
 
-The last lines give the total usage and stage time, and "Priced from the model catalogue of <date> when each call finished."
+The last lines give the total usage and the working time over every run, and "Priced from the model catalogue of <date> when each call finished."
 
 ## Across all projects: Home → This week
 

package/dist/tutorials/Project-Page.md

@@ -20,7 +20,7 @@ The page opens where the next action points: the failed step, the held review or
 
 ### The run cost line
 
-When a run has ended (done, done with problems, failed or cancelled), a line under the title sums it up, for example `This run cost $0.42 · ~$3.10 via API · 12 min end to end`. A run that ended early says **Spent so far** instead, and calls without a known price add "plus unpriced calls". **See cost by stage** opens the **Cost** section. The line is hidden while the run is going and when it spent nothing. See [Costs and Run Cost](Costs-and-Run-Cost).
+When a run has ended (done, done with problems, failed or cancelled), a line under the title sums it up, for example `This run cost $0.42 · ~$3.10 via API · 12 min of work`: only the time Slopify was working, never the time waiting on you, a review or a limit. A run that ended early says **Spent so far** instead, and calls without a known price add "plus unpriced calls". **See cost by stage** opens the **Cost** section. The line is hidden while the run is going and when it spent nothing. While the run is going, a clock sits there instead: `Working for 9 min 30 s`, ticking while a step runs; while it is paused or waits on you it holds still and reads `9 min 30 s of work so far`. See [Costs and Run Cost](Costs-and-Run-Cost).
 
 ### Time left