Your experts know the business.Your experts know the business.Let them own its rules.Let them own its rules.
In Lispektor, the people in operations and the business write the rules your systems run, with AI to help them draft. Your systems connect to Lispektor, so a change to a rule doesn't wait for a code release.
Two teams. One set of rules.
Experts write the rules in Lispektor, with AI to help. Engineers connect Lispektor to your systems and choose the building blocks.
For the business
Operations, finance, risk, support.
- Draft rules with AI
- Read and change them as flows
- Follow every run in real time
- See who changed what
For engineering
Set the limits once.
- Connect Lispektor to your systems
- Approve the blocks experts can use
- Roll back anytime
AI is changing who understands the rules.
AI writes more of your code.
Every week, more of your software is generated.
Rules get buried deeper.
The logic that runs the business ends up where nobody on the team reads.
Experts lose sight of what's live.
Ops and finance stop knowing the rules they answer for.
Lispektor gives rules a home outside the code.
The rules you move to Lispektor become flows your experts write with AI and change themselves.
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')
switch (ticket.channel) { case 'chat': return route(L1) }
const approved = blocks.filter(b => b.org === org.id)
await audit.log({ rule: 'refund', by: ctx.user, v: 13 })
// generated: escalation policy v7 (do not edit by hand)
if (customer.tier === 'vip' && wait > 30 * MIN) route(L2)
const limit = overrides[org]?.refund ?? REFUND_LIMIT
export function shouldEscalate(t: Ticket) { /* … */ }
if (order.total > cfg.limits.refund[region] && !user.flags.vip) {
return escalate(order, Role.MANAGER, { reason: 'threshold' })
}
const rule = await ruleset.resolve(org, 'refund.v12')
// TODO: who owns this? limit changed in #4821
export const REFUND_LIMIT = process.env.REFUND_LIMIT ?? 500
if (risk.score(order) > 0.82) queue.push(order, 'fraud')Lispektor checks every change before it goes live.
Every path returns a result. Every value has the right type. Only approved blocks are used.
- Every path returns a result
- Amount is a number
- Only approved operations
Watch every rule as it runs.
Your experts don't just write the rules. They see them working, live.
Every run, as it happens
Each run shows up the moment it starts, with the path it took and what it decided.
Paused runs in view
See which runs are waiting for a manager, and for how long.
A dashboard for every rule
Volume, outcomes and timing, for the people who own the rule.
- #2841Order 88255 · $659Under $750 → approveApproved · 53 ms
- #2840Order 88865 · $1,060Over $750 → managerWaiting for a manager
- #2839Order 88476 · $421Under $750 → approveApproved · 50 ms
- #2838Order 88087 · $822Over $750 → managerApproved by Ana
- #2837Order 88697 · $183Under $750 → approveApproved · 47 ms
Engineers set the limits. Experts own the rules.
- 01
Engineers connect your systems
They integrate Lispektor and choose which blocks your experts can use. Once, not rule by rule.
- 02
Experts write the rules with AI
AI helps draft the flow. The expert reviews it, changes it and decides when it goes live.
- 03
Lispektor checks every change
Before it reaches your systems. Every version has a name and can be rolled back.
Put the rules backPut the rules backin your experts' hands.in your experts' hands.
Lispektor is coming soon. Start with the rule your team keeps waiting on.