expect(think.thinkLevel).toBe("high");

});

it("keeps --persist as ordinary text for inline directives", () => {

const model = parseInlineDirectives("please sync /model openai/gpt-4.1-mini --persist now");

expect(model.cleaned).toBe("please sync --persist now");

expect(model.hasModelDirective).toBe(true);

expect(model.rawModelDirective).toBe("openai/gpt-4.1-mini");

const think = parseInlineDirectives("/think high --persist");

expect(think.cleaned).toBe("--persist");

expect(think.hasThinkDirective).toBe(true);

expect(think.thinkLevel).toBe("high");

});

it("keeps --persist in ordinary messages", () => {

const parsed = parseInlineDirectives("please keep --persist in this text");

expect(parsed.cleaned).toBe("please keep --persist in this text");

});

it("preserves spacing when stripping think directives before paths", () => {

const res = extractThinkDirective("thats not /think high/tmp/hello");

expect(res.hasDirective).toBe(true);

expect(result?.shouldContinue).toBe(false);

expect(result?.reply?.text).toBe("⚙️ Usage footer: full.");

});

it("updates usage footer mode as a session preference", async () => {

const params = buildUsageParams();

params.command.commandBodyNormalized = "/usage tokens";

params.sessionEntry = {

sessionId: "target-session",

updatedAt: Date.now(),

responseUsage: "full",

};

params.sessionStore = { [params.sessionKey]: params.sessionEntry };

const result = await handleUsageCommand(params, true);

expect(result?.reply?.text).toBe("⚙️ Usage footer: tokens.");

expect(params.sessionEntry.responseUsage).toBe("tokens");

});

it("clears usage footer mode on off updates", async () => {

const params = buildUsageParams();

params.command.commandBodyNormalized = "/usage off";

params.sessionEntry = {

sessionId: "target-session",

updatedAt: Date.now(),

responseUsage: "full",

};

params.sessionStore = { [params.sessionKey]: params.sessionEntry };

const result = await handleUsageCommand(params, true);

expect(result?.reply?.text).toBe("⚙️ Usage footer: off.");

expect(params.sessionEntry.responseUsage).toBeUndefined();

});

});

describe("handleFastCommand", () => {

hasDirective: hasQueueDirective,

hasOptions: hasQueueOptions,

} = extractQueueDirective(modelCleaned);

const hasAnyDirective =

hasThinkDirective ||

hasVerboseDirective ||

hasTraceDirective ||

hasFastDirective ||

hasReasoningDirective ||

hasElevatedDirective ||

hasExecDirective ||

hasStatusDirective ||

hasModelDirective ||

hasQueueDirective;

// Later directives see text cleaned by earlier directives; preserve that ordering.

return {

cleaned: queueCleaned,

cleaned: hasAnyDirective ? queueCleaned : body.trim(),

hasThinkDirective,

thinkLevel,

rawThinkLevel,

verboseLevel: resetTriggered ? existingEntry?.verboseLevel : existingEntry?.verboseLevel,

reasoningLevel: resetTriggered ? existingEntry?.reasoningLevel : existingEntry?.reasoningLevel,

ttsAuto: resetTriggered ? existingEntry?.ttsAuto : existingEntry?.ttsAuto,

responseUsage: !resetTriggered ? existingEntry?.responseUsage : undefined,

responseUsage: existingEntry?.responseUsage,

modelOverride: resetTriggered ? existingEntry?.modelOverride : existingEntry?.modelOverride,

providerOverride: resetTriggered

? existingEntry?.providerOverride

expect(result.sessionCtx.SessionKey).toBe("agent:main:main");

});

it("preserves usage footer mode during fast reset bootstrap", async () => {

const home = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-fast-reset-usage-"));

const storePath = path.join(home, "sessions.json");

const sessionKey = "agent:main:telegram:123";

await seedFastPathSessionStore(storePath, {

[sessionKey]: {

sessionId: "existing-fast-reset-usage",

updatedAt: Date.now(),

responseUsage: "full",

},

});

const result = initFastReplySessionState({

ctx: buildGetReplyCtx({

Body: "/reset",

RawBody: "/reset",

CommandBody: "/reset",

SessionKey: sessionKey,

}),

cfg: { session: { store: storePath } } as OpenClawConfig,

agentId: "main",

commandAuthorized: true,

workspaceDir: home,

});

expect(result.resetTriggered).toBe(true);

expect(result.sessionEntry.responseUsage).toBe("full");

});

it("maps explicit gateway origin into command context", () => {

const command = buildFastReplyCommandContext({

ctx: buildGetReplyCtx({

expect(store[sessionKey]?.ttsAuto).toBe("always");

});

it("preserves usage footer mode across daily rollover", async () => {

const root = await makeCaseDir("openclaw-daily-rollover-usage-");

const storePath = path.join(root, "sessions.json");

const sessionKey = "agent:main:discord:channel:daily-rollover-usage";

const existingSessionId = "session-before-daily-reset-usage";

const staleStartedAt = Date.now() - 48 * 60 * 60 * 1000;

await writeSessionStoreFast(storePath, {

[sessionKey]: {

sessionId: existingSessionId,

updatedAt: staleStartedAt,

sessionStartedAt: staleStartedAt,

lastInteractionAt: staleStartedAt,

responseUsage: "full",

},

});

const result = await initSessionState({

ctx: {

RawBody: "hello again",

ChatType: "channel",

SessionKey: sessionKey,

},

cfg: { session: { store: storePath } } as OpenClawConfig,

commandAuthorized: true,

});

expect(result.isNewSession).toBe(true);

expect(result.sessionId).not.toBe(existingSessionId);

expect(result.sessionEntry.responseUsage).toBe("full");

});

it("clears an auto-fallback model override on an implicit daily stale rollover (#90119)", async () => {

// Counterpart: auto-created fallback overrides must still be cleared on a

// daily rollover so stale sessions return to the configured default.

let persistedTrace: string | undefined;

let persistedReasoning: string | undefined;

let persistedTtsAuto: TtsAutoMode | undefined;

let persistedResponseUsage: SessionEntry["responseUsage"];

let persistedModelOverride: string | undefined;

let persistedProviderOverride: string | undefined;

let persistedModelOverrideSource: SessionEntry["modelOverrideSource"];

persistedTrace = entry.traceLevel;

persistedReasoning = entry.reasoningLevel;

persistedTtsAuto = entry.ttsAuto;

persistedResponseUsage = entry.responseUsage;

persistedModelOverride = entry.modelOverride;

persistedProviderOverride = entry.providerOverride;

persistedModelOverrideSource = entry.modelOverrideSource;

persistedTrace = entry.traceLevel;

persistedReasoning = entry.reasoningLevel;

persistedTtsAuto = entry.ttsAuto;

persistedResponseUsage = entry.responseUsage;

}

// When a reset trigger (/new, /reset) starts a new session, also rotate the

// underlying CLI conversation and carry forward spawn lineage/label.

traceLevel: persistedTrace ?? baseEntry?.traceLevel,

reasoningLevel: persistedReasoning ?? baseEntry?.reasoningLevel,

ttsAuto: persistedTtsAuto ?? baseEntry?.ttsAuto,

responseUsage: baseEntry?.responseUsage,

responseUsage: persistedResponseUsage ?? baseEntry?.responseUsage,

usageFamilyKey,

usageFamilySessionIds,

modelOverride: persistedModelOverride ?? baseEntry?.modelOverride,