// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// roll hours up into projects → real profit per project, in real time
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// roll hours up into projects → real profit per project, in real time
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// roll hours up into projects → real profit per project, in real time
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// roll hours up into projects → real profit per project, in real time
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// roll hours up into projects → real profit per project, in real time
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// roll hours up into projects → real profit per project, in real time
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// roll hours up into projects → real profit per project, in real time
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — every hour tracked honestly, on the device
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // no cloud, no surveillance
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// roll hours up into projects → real profit per project, in real time
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// activity classified on-device — the studio runs entirely on this
const week = sum(sessions, "productive"); // 37.5h this week, +27%
const team = await Org.active(); // 12 people, one shared workspace
export const live = stream(team, week, { realtime: true });
// timeros — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // 37.5h this week · +27%
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // 37.5h this week · +27%
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // 37.5h this week · +27%
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // 37.5h this week · +27%
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // 37.5h this week · +27%
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // 37.5h this week · +27%
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // 37.5h this week · +27%
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — time tracked honestly on the device, rolled up into projects, payroll and live profit per client
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // no cloud, no surveillance
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects → real profit per project, in real time, classified on-device with no surveillance
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // 37.5h this week · +27%
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
How we work
A calm, honest way to build.
No theatre, no churn of junior hands, no surprise invoices — a short, clear path from the first call to software that earns its place.
01Understand
02Design
03Build
04Run
The process, up close
What each step really means.
01
Understand
We start with the problem, the people, and the constraints — not a feature list. A short, sharp discovery that gets us to the real shape of the work.
02
Design
Calm, considered interfaces and a sound architecture beneath them. You see and feel the product early, while it is still cheap to change.
03
Build
Tight iterations, working software every step, no theatre. We ship in slices you can actually use, react to, and steer.
04
Run
Launch is the start, not the finish. We stay on to measure, refine, and keep the thing healthy as it meets the real world.
BriefDesignBuildAI agentAPITestDeployAutomateReviewShipRunClient portalDataSync
Ways to work together
Three shapes of engagement.
Three on-ramps into the same calm system — pick the shape that fits where you are.
Project build
You have a clear outcome in mind.
A defined product, platform, or feature — scoped after a short discovery, quoted clearly, and delivered end to end. Best when you want it built properly the first time.
Ongoing partnership
You need a team, not a one-off.
We act as your product engineering team — designing, building, and shipping in tight iterations. The same senior hands stay with you as the product grows.
Advisory & review
You need senior judgement, fast.
Architecture reviews, technical due diligence, a second opinion before you commit. Short, sharp, and high-leverage — days, not months.
Pricing
Most projects are fixed-scope: a short paid discovery, then a clear quote you approve before we build. Longer partnerships run on a simple monthly rate.
Either way you get the same thing — no surprise invoices, no lock-in, and no padding the timeline with people who aren’t needed. We’d rather quote honestly and keep the relationship than win the line item.
Discovery first
A short, paid discovery to get to the real shape of the work before anyone quotes a line of code.
Working software, early
You see and steer the product in slices you can actually use — not a big reveal at the end.
Direct access
You talk directly to the people building it — no hand-offs, no telephone game.
You own it all
Code, design, accounts, infrastructure — yours. No lock-in, no hostage data, clean handover whenever you want.
Ready to start the conversation?
Tell us what you have in mind. We reply to every serious enquiry — usually within a day.