Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import {
type OrchestrationCommand,
type OrchestrationEvent,
type OrchestrationReadModel,
} from "@akeru/contracts";
import * as Crypto from "effect/Crypto";
import * as Effect from "effect/Effect";
import type * as PlatformError from "effect/PlatformError";
import { OrchestrationCommandInvariantError } from "../Errors.ts";
import type { OrchestrationDispatchActor } from "../Services/OrchestrationEngine.ts";
import { requireThreadNotArchived } from "../commandInvariants.ts";
import {
hasOpenBlockingRequest,
nowIso,
threadHasQueuedTurnStart,
withEventBase,
type DecideOrchestrationCommandResult,
} from "./eventBase.ts";
export const decideThreadVisibility = Effect.fn("decideThreadVisibility")(function* ({
command,
readModel,
}: {
readonly command: Extract<
OrchestrationCommand,
{ type: "thread.settle" | "thread.unsettle" | "thread.snooze" | "thread.unsnooze" }
>;
readonly readModel: OrchestrationReadModel;
readonly actor?: OrchestrationDispatchActor;
}): Effect.fn.Return<
DecideOrchestrationCommandResult,
OrchestrationCommandInvariantError | PlatformError.PlatformError,
Crypto.Crypto
> {
switch (command.type) {
case "thread.settle": {
const thread = yield* requireThreadNotArchived({
readModel,
command,
threadId: command.threadId,
});
// Server-side twin of the client's canSettle session check: a stale
// or raced client must not settle a thread whose session is coming
// alive or working.
if (thread.session?.status === "starting" || thread.session?.status === "running") {
return yield* new OrchestrationCommandInvariantError({
commandType: command.type,
detail: `thread ${command.threadId} has an active session and cannot be settled`,
});
}
// Pending approval / user-input requests are blocked-on-you work: a
// raced or stale client must not park them behind a settled override
// that would surface only after the request resolves.
if (hasOpenBlockingRequest(thread)) {
return yield* new OrchestrationCommandInvariantError({
commandType: command.type,
detail: `thread ${command.threadId} has a pending approval or user-input request and cannot be settled`,
});
}
const occurredAt = yield* nowIso;
// Settling inside the adoption window would hide just-requested work.
if (threadHasQueuedTurnStart(thread, occurredAt)) {
return yield* new OrchestrationCommandInvariantError({
commandType: command.type,
detail: `thread ${command.threadId} has a queued turn start and cannot be settled`,
});
}
// Settling an already-settled thread re-emits with the original
// settledAt: the engine rejects zero-event commands, and bulk-settle /
// double-click must stay silent no-ops rather than surface errors.
const alreadySettled = thread.settledOverride === "settled" && thread.settledAt !== null;
const settledEvent = {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt,
commandId: command.commandId,
})),
type: "thread.settled" as const,
payload: {
threadId: command.threadId,
settledAt: alreadySettled ? thread.settledAt : occurredAt,
// A re-emission is a projected no-op: keep the existing updatedAt
// so duplicate settles neither rewind nor churn ordering. A fresh
// settle stamps the command time.
updatedAt: alreadySettled ? thread.updatedAt : occurredAt,
},
};
// Settling is "I'm done with this": clear states that would keep the
// row pinned or snoozed instead of showing the new settled state.
const companionEvents: Array<Omit<OrchestrationEvent, "sequence">> = [];
if (thread.pinnedAt != null) {
companionEvents.push({
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt,
commandId: command.commandId,
})),
type: "thread.unpinned" as const,
payload: {
threadId: command.threadId,
updatedAt: occurredAt,
},
});
}
if (thread.snoozedUntil != null) {
companionEvents.push({
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt,
commandId: command.commandId,
})),
type: "thread.unsnoozed",
payload: {
threadId: command.threadId,
reason: "user",
updatedAt: occurredAt,
},
});
}
return companionEvents.length > 0 ? [settledEvent, ...companionEvents] : settledEvent;
}
case "thread.unsettle": {
const thread = yield* requireThreadNotArchived({
readModel,
command,
threadId: command.threadId,
});
// Idempotent by re-emission (see thread.settle): reducing the event a
// second time lands on the same override state. A re-emission keeps
// the existing updatedAt so duplicates do not churn ordering.
const alreadyPinnedActive = thread.settledOverride === "active";
const occurredAt = yield* nowIso;
return {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt,
commandId: command.commandId,
})),
type: "thread.unsettled",
payload: {
threadId: command.threadId,
reason: command.reason,
updatedAt: alreadyPinnedActive ? thread.updatedAt : occurredAt,
},
};
}
case "thread.snooze": {
const thread = yield* requireThreadNotArchived({
readModel,
command,
threadId: command.threadId,
});
const occurredAt = yield* nowIso;
// A wake time in the past would create a thread that is snoozed and
// woken at once — the row would never leave the inbox but still carry
// snooze state. Reject instead of silently normalizing. The negated
// comparison also catches unparseable wake times (IsoDateTime is
// structurally just a string): NaN fails every comparison, and an
// unparseable snoozedUntil must never persist.
if (!(Date.parse(command.snoozedUntil) > Date.parse(occurredAt))) {
return yield* new OrchestrationCommandInvariantError({
commandType: command.type,
detail: `thread ${command.threadId} snooze wake time ${command.snoozedUntil} is not in the future`,
});
}
// Blocked-on-you work must not be snoozed away: a pending approval or
// user-input request is the agent waiting on the user, and hiding it
// defeats the request. (A running session IS snoozable — snooze only
// affects visibility, never the agent.)
if (hasOpenBlockingRequest(thread)) {
return yield* new OrchestrationCommandInvariantError({
commandType: command.type,
detail: `thread ${command.threadId} has a pending approval or user-input request and cannot be snoozed`,
});
}
// A queued turn start — a user message no turn has adopted yet — is
// invisible pending work: no session, no pending flags. Snoozing in
// that window would hide a just-requested turn exactly the way settle
// would.
if (threadHasQueuedTurnStart(thread, occurredAt)) {
return yield* new OrchestrationCommandInvariantError({
commandType: command.type,
detail: `thread ${command.threadId} has a queued turn start and cannot be snoozed`,
});
}
// Re-snoozing an already-snoozed thread to the SAME wake time is a
// duplicate (double-click, raced clients): re-emit with the original
// timestamps so the projection is a no-op. A different wake time is a
// real change and stamps fresh.
const existingSnoozedAt =
thread.snoozedUntil === command.snoozedUntil && thread.snoozedAt != null
? thread.snoozedAt
: null;
return {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt,
commandId: command.commandId,
})),
type: "thread.snoozed",
payload: {
threadId: command.threadId,
snoozedUntil: command.snoozedUntil,
snoozedAt: existingSnoozedAt ?? occurredAt,
updatedAt: existingSnoozedAt !== null ? thread.updatedAt : occurredAt,
},
};
}
case "thread.unsnooze": {
const thread = yield* requireThreadNotArchived({
readModel,
command,
threadId: command.threadId,
});
// Idempotent by re-emission (see thread.settle): waking a thread that
// is not snoozed lands on the same null state without churning
// updatedAt.
const alreadyAwake = thread.snoozedUntil == null;
const occurredAt = yield* nowIso;
return {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt,
commandId: command.commandId,
})),
type: "thread.unsnoozed",
payload: {
threadId: command.threadId,
reason: command.reason,
updatedAt: alreadyAwake ? thread.updatedAt : occurredAt,
},
};
}
}
});