@raidiant/notifai 10.1.0 → 10.1.2

package/src/session-activation.ts

@@ -1,61 +0,0 @@
-import type { HookHarness } from './hooks.js'
-import { Buffer } from 'node:buffer'
-import { GUIDANCE_CONTEXT_MAX_BYTES, boundedEffectiveGuidance } from './guidance-render.js'
-
-const ROOT_OWNERSHIP =
-  'Notifai is enabled for this Project. The effective, provenance-marked guidance below governs Notification Requests. ' +
-  'Missing CLI readiness is handled through `notifai init --json`.'
-
-export const WORKER_ACTIVATION_CONTEXT =
-  'Notifai worker context: an Agent Event is a meaningful occurrence in your work; a Notification Request is a deliberate User-visible message about one. Report Agent Events to the parent and do not send Notification Requests unless the parent explicitly delegated that ownership. If delegated, load the Notifai skill and run `notifai guidance` before composing one.'
-
-export const MISSING_LIFECYCLE_GUIDANCE_CONTEXT =
-  'Notifai is active, but lifecycle guidance could not be loaded. Run `notifai guidance` once before deciding whether or how to send a Notification Request.'
-
-function rootActivationContext(cwd: string, env: NodeJS.ProcessEnv): string {
-  const guidance = boundedEffectiveGuidance({
-    cwd,
-    env,
-    maxBytes: GUIDANCE_CONTEXT_MAX_BYTES - Buffer.byteLength(`${ROOT_OWNERSHIP}\n\n`, 'utf8'),
-  })
-  return `${ROOT_OWNERSHIP}\n\n${guidance.ok ? guidance.content : guidance.fallback}`
-}
-
-/** One lifecycle meaning, encoded for each harness output contract. */
-export function sessionActivationOutput(
-  harness: HookHarness | undefined,
-  hookEventName: 'SessionStart' | 'SubagentStart',
-  cwd: string = process.cwd(),
-  env: NodeJS.ProcessEnv = process.env,
-): string | undefined {
-  const context = hookEventName === 'SubagentStart'
-    ? WORKER_ACTIVATION_CONTEXT
-    : rootActivationContext(cwd, env)
-  if (harness === 'opencode' || harness === 'openclaw') return context
-  if (harness === 'cursor') {
-    return JSON.stringify({ additional_context: context })
-  }
-  if (harness === 'claude-code' || harness === 'codex') {
-    return JSON.stringify({
-      hookSpecificOutput: {
-        hookEventName,
-        additionalContext: context,
-      },
-    })
-  }
-  return undefined
-}
-
-/**
- * Cursor currently accepts sessionStart context without reliably delivering it
- * to the model. Its native post-Stop follow-up is the narrow fallback and is
- * claimed once per conversation by the hook-state layer.
- */
-export function cursorStopActivationOutput(
-  cwd: string = process.cwd(),
-  env: NodeJS.ProcessEnv = process.env,
-): string {
-  return JSON.stringify({
-    followup_message: rootActivationContext(cwd, env),
-  })
-}

package/src/session-end-log-lock-worker.test.ts

@@ -1,35 +0,0 @@
-import { existsSync, writeFileSync } from 'node:fs'
-import { describe, expect, it } from 'vitest'
-import { withFileLock } from './file-lock.js'
-
-const workerMode = process.env['NOTIFAI_SESSION_END_LOG_LOCK_WORKER_MODE']
-const sleep = new Int32Array(new SharedArrayBuffer(4))
-
-function waitFor(file: string): void {
-  const deadline = Date.now() + 15_000
-  while (!existsSync(file)) {
-    if (Date.now() >= deadline) throw new Error(`timed out waiting for ${file}`)
-    Atomics.wait(sleep, 0, 0, 2)
-  }
-}
-
-if (workerMode === undefined) {
-  describe('SessionEnd log lock worker', () => {
-    it('stays dormant outside the CLI deadline regression', () => {
-      expect(workerMode).toBeUndefined()
-    })
-  })
-} else {
-  describe('SessionEnd log lock worker', () => {
-    it('holds a live bakery ticket until the parent releases it', () => {
-      withFileLock(
-        process.env['NOTIFAI_SESSION_END_LOG_LOCK_PATH']!,
-        () => {
-          writeFileSync(process.env['NOTIFAI_SESSION_END_LOG_LOCK_READY']!, workerMode)
-          waitFor(process.env['NOTIFAI_SESSION_END_LOG_LOCK_RELEASE']!)
-        },
-        { waitMs: 15_000 },
-      )
-    })
-  })
-}

package/src/session-labels.test.ts

@@ -1,490 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  writeFileSync,
-} from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { describe, expect, it } from 'vitest'
-import { stateDir } from './config.js'
-import {
-  formatSessionFirstSeen,
-  renameStoredSessionLabel,
-  resolveSessionLabel,
-} from './session-labels.js'
-
-function fixture(): { env: NodeJS.ProcessEnv; now: number } {
-  const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-session-labels-'))
-  return {
-    env: { XDG_STATE_HOME: root },
-    now: new Date(2026, 7, 20, 14, 5).getTime(),
-  }
-}
-
-describe('semantic session labels', () => {
-  it('freezes the first explicit task label for the immutable session', () => {
-    const { env, now } = fixture()
-    expect(
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId: 'opaque-session-one',
-        harness: 'claude-code',
-        explicitLabel: '  Semantic   session names  ',
-      }),
-    ).toEqual({ ok: true, label: 'Semantic session names', source: 'explicit' })
-
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 1_000,
-        sessionId: 'opaque-session-one',
-        harness: 'claude-code',
-        explicitLabel: 'A later unrelated label',
-      }),
-    ).toEqual({ ok: true, label: 'Semantic session names', source: 'explicit' })
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 2_000,
-        sessionId: 'opaque-session-one',
-        harness: 'claude-code',
-        explicitLabel: 'x'.repeat(100),
-      }),
-    ).toEqual({ ok: true, label: 'Semantic session names', source: 'explicit' })
-  })
-
-  it('prefers the environment-supplied title over an explicit label, making the flag safe everywhere', () => {
-    // An agent must never need to know which environments name their own
-    // sessions: where one does, the explicit label is simply not used.
-    const { env, now } = fixture()
-    expect(
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId: 'managed-session',
-        harness: 'opencode',
-        harnessLabel: 'NotifAI question lifecycle',
-        explicitLabel: 'Agent-chosen name',
-      }),
-    ).toEqual({ ok: true, label: 'NotifAI question lifecycle', source: 'harness' })
-  })
-
-  it('upgrades a frozen fallback to the environment title even when an explicit label rides along', () => {
-    const { env, now } = fixture()
-    const frozen = resolveSessionLabel({ env, now, sessionId: 'late-title' })
-    expect(frozen).toMatchObject({ ok: true, source: 'fallback' })
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 1,
-        sessionId: 'late-title',
-        harness: 'opencode',
-        harnessLabel: 'Worktree semantic title',
-        explicitLabel: 'Agent-chosen name',
-      }),
-    ).toEqual({ ok: true, label: 'Worktree semantic title', source: 'harness' })
-  })
-
-  it('uses a trusted harness title when no explicit task label exists', () => {
-    const { env, now } = fixture()
-    expect(
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId: 'opencode-session',
-        harness: 'opencode',
-        harnessLabel: 'NotifAI question lifecycle',
-      }),
-    ).toEqual({ ok: true, label: 'NotifAI question lifecycle', source: 'harness' })
-  })
-
-  it('replaces a frozen generated fallback when a managed semantic title appears later', () => {
-    const { env, now } = fixture()
-    const frozen = resolveSessionLabel({
-      env,
-      now,
-      sessionId: 'claude-session-before-orca-metadata',
-      harness: 'claude-code',
-    })
-    expect(frozen.ok && frozen.source).toBe('fallback')
-
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 1_000,
-        sessionId: 'claude-session-before-orca-metadata',
-        harness: 'claude-code',
-        harnessLabel: 'Worker - semantic session implementation',
-      }),
-    ).toEqual({
-      ok: true,
-      label: 'Worker - semantic session implementation',
-      source: 'harness',
-    })
-  })
-
-  it('replaces a frozen generated fallback with a later explicit task name, once', () => {
-    const { env, now } = fixture()
-    const frozen = resolveSessionLabel({ env, now, sessionId: 'late-named', harness: 'codex' })
-    expect(frozen.ok && frozen.source).toBe('fallback')
-
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 1_000,
-        sessionId: 'late-named',
-        harness: 'codex',
-        explicitLabel: 'Fix checkout retries',
-      }),
-    ).toEqual({ ok: true, label: 'Fix checkout retries', source: 'explicit' })
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 2_000,
-        sessionId: 'late-named',
-        harness: 'codex',
-        explicitLabel: 'A different later name',
-      }),
-    ).toEqual({ ok: true, label: 'Fix checkout retries', source: 'explicit' })
-  })
-
-  it('disambiguates an upgraded name against every other stored session', () => {
-    const { env, now } = fixture()
-    expect(
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId: 'other-session',
-        harness: 'codex',
-        explicitLabel: 'Release preparation',
-      }),
-    ).toEqual({ ok: true, label: 'Release preparation', source: 'explicit' })
-    const frozen = resolveSessionLabel({ env, now, sessionId: 'upgraded', harness: 'codex' })
-    expect(frozen.ok && frozen.source).toBe('fallback')
-
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 1_000,
-        sessionId: 'upgraded',
-        harness: 'codex',
-        explicitLabel: 'Release preparation',
-      }),
-    ).toEqual({ ok: true, label: 'Release preparation · Codex', source: 'explicit' })
-  })
-
-  it('rejects an invalid explicit name instead of silently keeping the fallback', () => {
-    const { env, now } = fixture()
-    const frozen = resolveSessionLabel({ env, now, sessionId: 'still-fallback', harness: 'codex' })
-    expect(frozen.ok && frozen.source).toBe('fallback')
-
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 1_000,
-        sessionId: 'still-fallback',
-        harness: 'codex',
-        explicitLabel: 'x'.repeat(65),
-      }),
-    ).toEqual({
-      ok: false,
-      error: '--session-label (or NOTIFAI_SESSION_LABEL) must be at most 64 characters.',
-    })
-    expect(
-      resolveSessionLabel({ env, now: now + 2_000, sessionId: 'still-fallback', harness: 'codex' }),
-    ).toEqual(frozen)
-  })
-
-  it('does not freeze OpenCode placeholder titles before the semantic title arrives', () => {
-    const { env, now } = fixture()
-    const file = path.join(stateDir(env), 'session-labels.json')
-    expect(
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId: 'opencode-pending',
-        harness: 'opencode',
-        harnessLabel: 'New session - 2026-08-20T13:05:00.000Z',
-        harnessLabelPending: true,
-      }),
-    ).toEqual({
-      ok: false,
-      error:
-        "OpenCode is still generating this session's title; retry shortly or pass --session-label.",
-    })
-    expect(existsSync(file)).toBe(false)
-
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 1_000,
-        sessionId: 'opencode-pending',
-        harness: 'opencode',
-        harnessLabel: 'Semantic session names',
-      }),
-    ).toEqual({ ok: true, label: 'Semantic session names', source: 'harness' })
-  })
-
-  it('allows an explicit task name while a native title is still pending', () => {
-    const { env, now } = fixture()
-    expect(
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId: 'opencode-pending',
-        harness: 'opencode',
-        harnessLabelPending: true,
-        explicitLabel: 'Verify release candidate',
-      }),
-    ).toEqual({ ok: true, label: 'Verify release candidate', source: 'explicit' })
-  })
-
-  it('falls back to a stable generated name without exposing the session id', () => {
-    const { env, now } = fixture()
-    const resolved = resolveSessionLabel({
-      env,
-      now,
-      sessionId: 'opaque-thread-1234567890',
-      harness: 'codex',
-    })
-    expect(resolved).toEqual({
-      ok: true,
-      label: 'Ivory Koala',
-      source: 'fallback',
-    })
-
-    const stored = readFileSync(path.join(stateDir(env), 'session-labels.json'), 'utf8')
-    expect(stored).not.toContain('opaque-thread-1234567890')
-  })
-
-  it('migrates a frozen date fallback when no semantic candidate exists', () => {
-    const { env, now } = fixture()
-    const file = path.join(stateDir(env), 'session-labels.json')
-    expect(
-      resolveSessionLabel({ env, now, sessionId: 'opaque-thread-1234567890', harness: 'codex' }),
-    ).toEqual({ ok: true, label: 'Ivory Koala', source: 'fallback' })
-
-    const store = JSON.parse(readFileSync(file, 'utf8')) as {
-      sessions: Record<string, { label: string }>
-    }
-    const key = Object.keys(store.sessions)[0]
-    const record = key === undefined ? undefined : store.sessions[key]
-    if (record === undefined) throw new Error('expected one stored session')
-    record.label = 'Codex session · Aug 20, 2026 14:05'
-    writeFileSync(file, `${JSON.stringify(store, null, 2)}\n`)
-
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 1_000,
-        sessionId: 'opaque-thread-1234567890',
-        harness: 'codex',
-      }),
-    ).toEqual({ ok: true, label: 'Ivory Koala', source: 'fallback' })
-    expect(readFileSync(file, 'utf8')).not.toContain('Codex session ·')
-
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 2_000,
-        sessionId: 'opaque-thread-1234567890',
-        harness: 'codex',
-        explicitLabel: 'Late semantic override',
-      }),
-    ).toEqual({ ok: true, label: 'Late semantic override', source: 'explicit' })
-  })
-
-  it('disambiguates repeated semantic titles without changing session identity', () => {
-    const { env, now } = fixture()
-    const labels = ['one', 'two', 'three', 'four'].map((sessionId) =>
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId,
-        harness: 'codex',
-        explicitLabel: 'Release preparation',
-      }),
-    )
-    expect(labels).toEqual([
-      { ok: true, label: 'Release preparation', source: 'explicit' },
-      { ok: true, label: 'Release preparation · Codex', source: 'explicit' },
-      {
-        ok: true,
-        label: 'Release preparation · Codex · Aug 20, 2026 14:05',
-        source: 'explicit',
-      },
-      {
-        ok: true,
-        label: 'Release preparation · Codex · Aug 20, 2026 14:05 · 2',
-        source: 'explicit',
-      },
-    ])
-  })
-
-  it('adds only an ordinal when generated fallback labels collide', () => {
-    const { env, now } = fixture()
-    const first = resolveSessionLabel({ env, now, sessionId: 'collision-8', harness: 'codex' })
-    const second = resolveSessionLabel({
-      env,
-      now,
-      sessionId: 'collision-112',
-      harness: 'codex',
-    })
-    expect(first).toEqual({
-      ok: true,
-      label: 'Winter Dolphin',
-      source: 'fallback',
-    })
-    expect(second).toEqual({
-      ok: true,
-      label: 'Winter Dolphin · 2',
-      source: 'fallback',
-    })
-  })
-
-  it('keeps astral native and disambiguated labels inside the wire bound', () => {
-    const { env, now } = fixture()
-    const long = '😀'.repeat(100)
-    const first = resolveSessionLabel({
-      env,
-      now,
-      sessionId: 'first',
-      harness: 'opencode',
-      harnessLabel: long,
-    })
-    const second = resolveSessionLabel({
-      env,
-      now,
-      sessionId: 'second',
-      harness: 'opencode',
-      harnessLabel: long,
-    })
-    expect(first.ok && first.label.length).toBeLessThanOrEqual(64)
-    expect(second.ok && second.label.length).toBeLessThanOrEqual(64)
-    expect(first.ok && first.label.endsWith('…')).toBe(true)
-  })
-
-  it('rejects blank and oversized explicit labels before storing them', () => {
-    const { env, now } = fixture()
-    expect(
-      resolveSessionLabel({ env, now, sessionId: 'blank', explicitLabel: '   ' }),
-    ).toEqual({
-      ok: false,
-      error: '--session-label (or NOTIFAI_SESSION_LABEL) must not be empty.',
-    })
-    expect(
-      resolveSessionLabel({ env, now, sessionId: 'long', explicitLabel: 'x'.repeat(65) }),
-    ).toEqual({
-      ok: false,
-      error: '--session-label (or NOTIFAI_SESSION_LABEL) must be at most 64 characters.',
-    })
-    expect(
-      resolveSessionLabel({ env, now, sessionId: 'emoji', explicitLabel: '😀'.repeat(33) }),
-    ).toEqual({
-      ok: false,
-      error: '--session-label (or NOTIFAI_SESSION_LABEL) must be at most 64 characters.',
-    })
-  })
-
-  it('rejects explicit identifiers and paths and never promotes unsafe native titles', () => {
-    const { env, now } = fixture()
-    env['HOME'] = '/Users/example'
-    const error =
-      '--session-label (or NOTIFAI_SESSION_LABEL) must not contain a session identifier, hash, or filesystem path.'
-
-    expect(
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId: 'ses_opaque123456',
-        explicitLabel: 'ses_opaque123456',
-      }),
-    ).toEqual({ ok: false, error })
-    expect(
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId: 'safe-session',
-        explicitLabel: 'Fix /Users/example/private-client',
-      }),
-    ).toEqual({ ok: false, error })
-    expect(
-      resolveSessionLabel({
-        env,
-        now,
-        sessionId: 'native-session',
-        harness: 'opencode',
-        harnessLabel: 'Fix /Users/example/private-client',
-      }),
-    ).toEqual({
-      ok: true,
-      label: 'Violet Crane',
-      source: 'fallback',
-    })
-  })
-
-  it('isolates an unreadable name store before creating a clean one', () => {
-    const { env, now } = fixture()
-    const file = path.join(stateDir(env), 'session-labels.json')
-    mkdirSync(path.dirname(file), { recursive: true })
-    writeFileSync(file, '{not json}\n')
-
-    expect(
-      resolveSessionLabel({
-      env,
-      now,
-      sessionId: 'new-session',
-      explicitLabel: 'Do not overwrite me',
-      }),
-    ).toEqual({ ok: true, label: 'Do not overwrite me', source: 'explicit' })
-    expect(readFileSync(file, 'utf8')).not.toBe('{not json}\n')
-    const backups = readdirSync(path.dirname(file)).filter((name) =>
-      /^session-labels\.invalid-[a-f0-9]{64}\.json$/u.test(name),
-    )
-    expect(backups).toHaveLength(1)
-    expect(readFileSync(path.join(path.dirname(file), backups[0]!), 'utf8')).toBe('{not json}\n')
-  })
-
-  it('formats first seen using the machine local calendar', () => {
-    const now = new Date(2026, 0, 2, 3, 4).getTime()
-    expect(formatSessionFirstSeen(now)).toBe('Jan 2, 2026 03:04')
-  })
-
-  it('explicitly replaces a semantic or fallback label after an authorized rename', () => {
-    const { env, now } = fixture()
-    resolveSessionLabel({
-      env,
-      now,
-      sessionId: 'rename-me',
-      harness: 'codex',
-      explicitLabel: 'Old job',
-    })
-
-    expect(
-      renameStoredSessionLabel({
-        env,
-        now: now + 1_000,
-        sessionId: 'rename-me',
-        harness: 'codex',
-        label: '  Completely   different job  ',
-      }),
-    ).toEqual({ ok: true, label: 'Completely different job', source: 'explicit' })
-    expect(
-      resolveSessionLabel({
-        env,
-        now: now + 2_000,
-        sessionId: 'rename-me',
-        harness: 'codex',
-        harnessLabel: 'Later task context',
-      }),
-    ).toEqual({
-      ok: true,
-      label: 'Completely different job',
-      source: 'explicit',
-    })
-  })
-})