@raidiant/notifai 9.2.2 → 10.0.0

package/src/project-enablement.test.ts

@@ -0,0 +1,55 @@
+import { execFileSync } from 'node:child_process'
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { describe, expect, it } from 'vitest'
+import {
+  disableProject,
+  enableProject,
+  projectBinding,
+  projectEnabled,
+} from './project-enablement.js'
+
+function git(cwd: string, ...args: string[]): void {
+  execFileSync('git', ['-C', cwd, ...args], { stdio: 'ignore' })
+}
+
+describe('Project enablement', () => {
+  it('is disabled by default and changes only through its User-owned marker', () => {
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-enablement-'))
+    const env = { XDG_CONFIG_HOME: path.join(root, 'config') }
+    const binding = projectBinding(root, env)
+    expect(binding).not.toBeNull()
+    expect(projectEnabled(binding)).toBe(false)
+
+    enableProject(binding!, new Date('2026-08-27T00:00:00.000Z'))
+    expect(projectEnabled(binding)).toBe(true)
+    disableProject(binding!)
+    expect(projectEnabled(binding)).toBe(false)
+  })
+
+  it('shares one decision across linked worktrees but not unrelated checkouts with the same name', () => {
+    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-enablement-git-'))
+    const repo = path.join(root, 'same-name')
+    const linked = path.join(root, 'linked')
+    const unrelatedParent = path.join(root, 'other')
+    const unrelated = path.join(unrelatedParent, 'same-name')
+    mkdirSync(repo, { recursive: true })
+    mkdirSync(unrelated, { recursive: true })
+    for (const cwd of [repo, unrelated]) {
+      git(cwd, 'init')
+      git(cwd, 'config', 'user.email', 'test@example.invalid')
+      git(cwd, 'config', 'user.name', 'Test')
+      writeFileSync(path.join(cwd, 'file'), 'x')
+      git(cwd, 'add', 'file')
+      git(cwd, 'commit', '-m', 'fixture')
+    }
+    git(repo, 'worktree', 'add', linked, '-b', 'linked')
+    const env = { XDG_CONFIG_HOME: path.join(root, 'config') }
+    const mainBinding = projectBinding(repo, env)
+    const linkedBinding = projectBinding(linked, env)
+    const unrelatedBinding = projectBinding(unrelated, env)
+    expect(linkedBinding?.markerPath).toBe(mainBinding?.markerPath)
+    expect(unrelatedBinding?.markerPath).not.toBe(mainBinding?.markerPath)
+  })
+})

package/src/project-enablement.ts

@@ -0,0 +1,99 @@
+import { execFileSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { existsSync, readFileSync, realpathSync, unlinkSync } from 'node:fs'
+import path from 'node:path'
+import { atomicWriteFileSync } from './atomic-file.js'
+import { globalConfigDir } from './config.js'
+import { inferInvocationContext } from './invocation-context.js'
+
+interface ProjectEnablementMarker {
+  version: 1
+  project: string
+  enabled: true
+  updated_at: string
+}
+
+export interface ProjectBinding {
+  project: string
+  markerPath: string
+}
+
+function gitCommonDirectory(cwd: string): string | null {
+  try {
+    const raw = execFileSync('git', ['-C', cwd, 'rev-parse', '--git-common-dir'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2_000,
+      windowsHide: true,
+    }).trim()
+    if (raw === '') return null
+    const resolved = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw)
+    try {
+      return realpathSync(resolved)
+    } catch {
+      return path.resolve(resolved)
+    }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Resolve the User-owned enablement record for this exact local Project.
+ *
+ * The opaque key binds the semantic Project id to Git's shared common
+ * directory. Linked worktrees therefore share one decision, while another
+ * checkout cannot borrow it merely by committing the same Project id.
+ */
+export function projectBinding(
+  cwd: string,
+  env: NodeJS.ProcessEnv = process.env,
+  explicitProject?: string | null,
+): ProjectBinding | null {
+  const project = explicitProject ?? inferInvocationContext(cwd).project
+  if (project === null) return null
+  const repository = gitCommonDirectory(cwd) ?? path.resolve(cwd)
+  const key = createHash('sha256')
+    .update('notifai-project-enablement-v1\0')
+    .update(repository)
+    .update('\0')
+    .update(project)
+    .digest('hex')
+  return {
+    project,
+    markerPath: path.join(globalConfigDir(env), 'project-enablement', `${key}.json`),
+  }
+}
+
+export function projectEnabled(binding: ProjectBinding | null): boolean {
+  if (binding === null || !existsSync(binding.markerPath)) return false
+  try {
+    const marker = JSON.parse(readFileSync(binding.markerPath, 'utf8')) as Partial<ProjectEnablementMarker>
+    return marker.version === 1 && marker.enabled === true && marker.project === binding.project
+  } catch {
+    return false
+  }
+}
+
+export function enableProject(binding: ProjectBinding, now: Date = new Date()): void {
+  const marker: ProjectEnablementMarker = {
+    version: 1,
+    project: binding.project,
+    enabled: true,
+    updated_at: now.toISOString(),
+  }
+  atomicWriteFileSync(binding.markerPath, `${JSON.stringify(marker, null, 2)}\n`, {
+    mode: 0o600,
+    preserveMode: false,
+    requireCurrentUserOwner: true,
+    directoryMode: 0o700,
+  })
+}
+
+export function disableProject(binding: ProjectBinding): void {
+  try {
+    unlinkSync(binding.markerPath)
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err
+  }
+}

package/src/question-timing.ts

@@ -0,0 +1,56 @@
+import { REPLY_MAX_WINDOW_SECONDS } from '@raidiant/notifai-protocol'
+
+/**
+ * Time before reply-window admission that the Stop owner may spend reading its
+ * input, serving terminal-first grace, resolving devices, and submitting.
+ *
+ * Grace is capped at six minutes and every network operation is independently
+ * bounded. Twenty minutes lets setup spend up to ten while preserving the
+ * separate completion margin below; neither may borrow from the answer window
+ * the service actually commits.
+ */
+export const QUESTION_WAITER_STARTUP_HEADROOM_SECONDS = 20 * 60
+
+/**
+ * Minimum lifetime still available when a question is admitted.
+ *
+ * The server window starts during submission, not when the hook process
+ * started. Keeping ten minutes beyond the requested window covers the bounded
+ * submit, clock skew, close fence, and route handoff. If setup used more of the
+ * allowance, the frozen question remains local for a successor owner instead
+ * of publishing a window this process cannot observe completely.
+ */
+export const QUESTION_SUBMISSION_COMPLETION_HEADROOM_SECONDS = 10 * 60
+
+/**
+ * The longest one Stop owner may live from process start.
+ *
+ * The service can accept an answer for up to 72 hours. Starting this budget
+ * before submission is deliberate: the startup allowance above ensures that
+ * even the maximum reply window still ends before the owner does.
+ */
+export const QUESTION_WAITER_CEILING_SECONDS =
+  REPLY_MAX_WINDOW_SECONDS + QUESTION_WAITER_STARTUP_HEADROOM_SECONDS
+
+/** Time for final fencing, diagnostics, stdout handoff, and clean process exit. */
+export const QUESTION_STOP_TEARDOWN_HEADROOM_SECONDS = 60
+
+/**
+ * Declared harness timeout for every Stop handler that owns Question Routing.
+ * It must outlive the runtime owner; otherwise the harness silently kills the
+ * only process capable of continuing the exact Agent Session.
+ */
+export const QUESTION_STOP_TIMEOUT_SECONDS =
+  QUESTION_WAITER_CEILING_SECONDS + QUESTION_STOP_TEARDOWN_HEADROOM_SECONDS
+
+/**
+ * Short Stop budget for harnesses that cannot own asynchronous Question
+ * Routing. They retire/refuse promptly and never wait through an answer window.
+ */
+export const NON_ROUTING_STOP_TIMEOUT_SECONDS = 540
+
+/**
+ * Pre-PID claim files came only from the former eight-minute owner. Retain that
+ * recovery bound instead of making a corrupt legacy file block for 72 hours.
+ */
+export const LEGACY_QUESTION_CLAIM_TTL_SECONDS = 480

package/src/readiness.ts

@@ -34,7 +34,14 @@ export type Remedy =
    * the CLI's to launch but the human's to complete, so an agent must still
    * treat it as out of reach.
    */
-  | { by: 'user-here'; summary: string; command: string; interactive?: boolean }
+  | {
+      by: 'user-here'
+      summary: string
+      command: string
+      interactive?: boolean
+      /** Stable agent-facing description of an unavoidable harness-owned action. */
+      user_action?: { code: string; harness: string; action: string; message: string }
+    }
   /**
    * A human somewhere else entirely — phone in hand, app store, permission
    * dialog. The class the old init could only print a sentence about, and the

package/src/send.ts

@@ -1,5 +1,4 @@
 import {
-  CLI_SOUNDS,
   COLLAPSE_KEY_MAX_BYTES,
   INTERRUPTION_LEVELS,
   MEDIA_MAX_ITEMS,
@@ -13,9 +12,6 @@ import {
   type MediaItemT,
   type NotificationDraftT,
   NOTIFICATION_KINDS,
-  DEFAULT_NOTIFICATION_KIND,
-  defaultSoundForKind,
-  type NotificationKind,
   PLATFORMS,
   type Platform,
   type QuestionT,
@@ -23,8 +19,7 @@ import {
   type SubmissionReceipt,
 } from '@raidiant/notifai-protocol'
 import type { CliConfig } from './config.js'
-
-type CliSound = (typeof CLI_SOUNDS)[number]
+import { isCliSoundRef, unknownSoundMessage } from './sound-ref.js'
 
 export interface SendFlags {
   title: string
@@ -34,6 +29,8 @@ export interface SendFlags {
   /** What this notification is; absent means update. */
   kind?: string
   project?: string
+  /** Deliberately omit Project identity even when config or cwd could supply one. */
+  projectless?: boolean
   /** Opaque exact Agent Session override. */
   sessionId?: string
   /** Human-readable Agent Session label override. */
@@ -215,18 +212,15 @@ export function buildDraft(
     }
   }
 
-  // Kind states what happened; the sound table turns that truth into the
-  // attention it deserves, so an honest sender gets the right sound without
-  // reasoning about audio. An explicit --sound and the user's saved preference
-  // both outrank it, and `none` still means silent.
-  const kindForSound: NotificationKind = flags.reply
-    ? 'question'
-    : ((flags.kind as NotificationKind | undefined) ?? DEFAULT_NOTIFICATION_KIND)
-  const sound = flags.sound ?? config.sound.value ?? defaultSoundForKind(kindForSound)
-  if (sound !== null && sound !== undefined && !CLI_SOUNDS.includes(sound as CliSound)) {
+  // Explicit --sound and the saved sound key outrank kind. The server is the
+  // one that applies kind, Project, and Account maps — stamping a kind default
+  // here would look like an explicit choice and skip those layers. `none` is
+  // still silent.
+  const sound = flags.sound !== undefined ? flags.sound : config.sound.value
+  if (sound !== null && sound !== undefined && !isCliSoundRef(sound)) {
     return {
       ok: false,
-      error: `Unknown sound "${sound}" — supported: ${CLI_SOUNDS.map((value) => `"${value}"`).join(', ')}.`,
+      error: unknownSoundMessage(sound),
     }
   }
   const level =
@@ -252,9 +246,8 @@ export function buildDraft(
     appleOptions.sound = null
     androidOptions.sound = null
   } else if (sound !== null && sound !== undefined) {
-    const semanticSound = sound as Exclude<(typeof CLI_SOUNDS)[number], 'none'>
-    appleOptions.sound = semanticSound
-    androidOptions.sound = semanticSound
+    appleOptions.sound = sound
+    androidOptions.sound = sound
   }
   if (flags.threadId !== undefined) {
     appleOptions.thread_id = flags.threadId
@@ -287,7 +280,12 @@ export function buildDraft(
     }
   }
 
-  const project = flags.project ?? config.project.value ?? invocation.inferredProject
+  if (flags.projectless === true && flags.project !== undefined) {
+    return { ok: false, error: 'Choose either --project or --projectless, not both.' }
+  }
+  const project = flags.projectless === true
+    ? undefined
+    : flags.project ?? config.project.value ?? invocation.inferredProject
 
   // Ids are derived from labels so an agent writing a one-liner does not have
   // to invent them, but they stay the stable thing it branches on afterwards.

package/src/session-activation.ts

@@ -3,12 +3,11 @@ import { Buffer } from 'node:buffer'
 import { GUIDANCE_CONTEXT_MAX_BYTES, boundedEffectiveGuidance } from './guidance-render.js'
 
 const ROOT_OWNERSHIP =
-  'Notifai is active for this session. The effective, provenance-marked guidance below governs Notification Requests. ' +
-  'Missing CLI readiness is handled through `notifai init --json`. ' +
-  'The root agent owns User-visible Notification Requests unless it explicitly delegates that ownership; workers report Agent Events to the parent.'
+  '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: report Agent Events to the parent; do not send User-visible Notification Requests unless the parent explicitly delegated that ownership. If delegated, load the Notifai skill and run `notifai guidance` before composing one.'
+  '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.'

package/src/session-labels.test.ts

@@ -1,9 +1,20 @@
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
+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, resolveSessionLabel } from './session-labels.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-'))
@@ -416,26 +427,64 @@ describe('semantic session labels', () => {
     })
   })
 
-  it('fails closed instead of replacing an unreadable name store', () => {
+  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')
 
-    const resolved = resolveSessionLabel({
+    expect(
+      resolveSessionLabel({
       env,
       now,
       sessionId: 'new-session',
       explicitLabel: 'Do not overwrite me',
-    })
-
-    expect(resolved.ok).toBe(false)
-    expect(!resolved.ok && resolved.error).toContain('session-name store is unreadable')
-    expect(readFileSync(file, 'utf8')).toBe('{not json}\n')
+      }),
+    ).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',
+    })
+  })
 })

package/src/session-labels.ts

@@ -1,12 +1,12 @@
 import { createHash } from 'node:crypto'
-import { existsSync, readFileSync } from 'node:fs'
+import { copyFileSync, existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { SESSION_LABEL_MAX_LENGTH } from '@raidiant/notifai-protocol'
 import { atomicWriteFileSync } from './atomic-file.js'
 import { stateDir } from './config.js'
 import { withFileLock } from './file-lock.js'
 import { generatedSessionLabel } from './generated-session-label.js'
-import { HARNESS_LABELS, type Harness } from './harnesses.js'
+import { HARNESS_LABELS, type SourceContextHarness } from './harnesses.js'
 
 const STORE_VERSION = 1
 const MONTHS = [
@@ -35,7 +35,7 @@ interface StoredSessionLabel {
   label: string
   source: SessionLabelSource
   first_seen_at: number
-  harness?: Harness
+  harness?: SourceContextHarness
 }
 
 interface SessionLabelStore {
@@ -46,13 +46,21 @@ interface SessionLabelStore {
 export interface SessionLabelInput {
   env: NodeJS.ProcessEnv
   sessionId: string
-  harness?: Harness
+  harness?: SourceContextHarness
   explicitLabel?: string
   harnessLabel?: string
   harnessLabelPending?: boolean
   now?: number
 }
 
+export interface SessionLabelRenameInput {
+  env: NodeJS.ProcessEnv
+  sessionId: string
+  label: string
+  harness?: SourceContextHarness
+  now?: number
+}
+
 export type SessionLabelResolution =
   | { ok: true; label: string; source: SessionLabelSource }
   | { ok: false; error: string }
@@ -70,6 +78,24 @@ function emptyStore(): SessionLabelStore {
   return { version: STORE_VERSION, sessions: {} }
 }
 
+function quarantineInvalidStore(file: string, raw: string): void {
+  const digest = createHash('sha256').update(raw).digest('hex')
+  const backup = path.join(path.dirname(file), `session-labels.invalid-${digest}.json`)
+  if (existsSync(backup)) {
+    if (readFileSync(backup, 'utf8') !== raw) {
+      throw new Error('the session-name store recovery backup does not match its content hash')
+    }
+    return
+  }
+  copyFileSync(file, backup)
+}
+
+function recoverInvalidStore(file: string, raw: string, store: SessionLabelStore): SessionLabelStore {
+  quarantineInvalidStore(file, raw)
+  writeStore(file, store)
+  return store
+}
+
 function storedRecord(candidate: unknown): StoredSessionLabel | null {
   if (typeof candidate !== 'object' || candidate === null) return null
   const value = candidate as Partial<StoredSessionLabel>
@@ -95,33 +121,42 @@ function storedRecord(candidate: unknown): StoredSessionLabel | null {
 
 function readStore(file: string): SessionLabelStore {
   if (!existsSync(file)) return emptyStore()
-  let parsed: unknown
+  let rawText: string
   try {
-    parsed = JSON.parse(readFileSync(file, 'utf8'))
+    rawText = readFileSync(file, 'utf8')
   } catch (err) {
     throw new Error(
       `the session-name store is unreadable: ${err instanceof Error ? err.message : String(err)}`,
     )
   }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(rawText)
+  } catch {
+    return recoverInvalidStore(file, rawText, emptyStore())
+  }
   if (typeof parsed !== 'object' || parsed === null) {
-    throw new Error('the session-name store is not a JSON object')
+    return recoverInvalidStore(file, rawText, emptyStore())
   }
   const raw = parsed as { version?: unknown; sessions?: unknown }
   if (raw.version !== STORE_VERSION) {
-    throw new Error(`unsupported session-name store version ${String(raw.version)}`)
+    return recoverInvalidStore(file, rawText, emptyStore())
   }
   if (typeof raw.sessions !== 'object' || raw.sessions === null) {
-    throw new Error('the session-name store has no sessions object')
+    return recoverInvalidStore(file, rawText, emptyStore())
   }
   const sessions: Record<string, StoredSessionLabel> = {}
+  let invalidRecordFound = false
   for (const [key, candidate] of Object.entries(raw.sessions)) {
     const record = storedRecord(candidate)
     if (!/^[a-f0-9]{64}$/.test(key) || record === null) {
-      throw new Error('the session-name store contains an invalid record')
+      invalidRecordFound = true
+      continue
     }
     sessions[key] = record
   }
-  return { version: STORE_VERSION, sessions }
+  const store = { version: STORE_VERSION, sessions } satisfies SessionLabelStore
+  return invalidRecordFound ? recoverInvalidStore(file, rawText, store) : store
 }
 
 function writeStore(file: string, store: SessionLabelStore): void {
@@ -203,6 +238,20 @@ function explicitCandidate(
   return { label: normalized, source: 'explicit' }
 }
 
+export function normalizeExplicitSessionLabel(
+  input: Pick<SessionLabelRenameInput, 'env' | 'sessionId' | 'label'>,
+): { ok: true; label: string } | { ok: false; error: string } {
+  const candidate = explicitCandidate(input.label, {
+    env: input.env,
+    sessionId: input.sessionId,
+  })
+  if (candidate === null) {
+    return { ok: false, error: '--session-label must not be empty.' }
+  }
+  if ('error' in candidate) return { ok: false, error: candidate.error }
+  return { ok: true, label: candidate.label }
+}
+
 function harnessLabelIsPending(
   value: string | undefined,
   input: SessionLabelInput,
@@ -260,7 +309,7 @@ function collisionKey(value: string): string {
 function uniqueLabel(
   base: string,
   source: SessionLabelSource,
-  harness: Harness | undefined,
+  harness: SourceContextHarness | undefined,
   now: number,
   used: ReadonlySet<string>,
 ): string {
@@ -389,3 +438,37 @@ export function resolveSessionLabel(input: SessionLabelInput): SessionLabelResol
     }
   }
 }
+
+/** Replace the local frozen label only after the Account-authoritative rename succeeds. */
+export function renameStoredSessionLabel(
+  input: SessionLabelRenameInput,
+): SessionLabelResolution {
+  const normalized = normalizeExplicitSessionLabel(input)
+  if (!normalized.ok) return normalized
+  const file = storePath(input.env)
+  const key = sessionKey(input.sessionId)
+  const now = input.now ?? Date.now()
+  try {
+    return withFileLock(`${file}.lock`, () => {
+      const store = readStore(file)
+      const existing = store.sessions[key]
+      store.sessions[key] = {
+        label: normalized.label,
+        source: 'explicit',
+        first_seen_at: existing?.first_seen_at ?? now,
+        ...(input.harness === undefined
+          ? existing?.harness === undefined
+            ? {}
+            : { harness: existing.harness }
+          : { harness: input.harness }),
+      }
+      writeStore(file, store)
+      return { ok: true, label: normalized.label, source: 'explicit' }
+    })
+  } catch (err) {
+    return {
+      ok: false,
+      error: `The Account label changed, but this machine could not save it locally: ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+}

package/src/skill.test.ts

@@ -225,7 +225,7 @@ describe('Notifai agent skill', () => {
     expect(send).toMatch(/kind and the project travel as their own\s+fields, never in it/i)
   })
 
-  it('lets callers repeat one immutable semantic session name without supplying its id', () => {
+  it('keeps initial labels stable and teaches the narrow exact-session rename exception', () => {
     const send = section('## Send')
     expect(send).toContain('--session-label')
     expect(send).toMatch(/2-6 words/i)
@@ -239,6 +239,11 @@ describe('Notifai agent skill', () => {
     expect(send).toMatch(/generated fallback name[\s\S]*replaced by a later\s+semantic name/i)
     expect(send).toMatch(/never pass\s+`--session-id`/i)
     expect(send).toMatch(/identifier, hash, or\s+filesystem path/i)
+    expect(send).toContain('notifai session rename')
+    expect(send).toMatch(/job changed completely[\s\S]{0,100}current\s+name would now mislead/i)
+    expect(send).toMatch(/never rename for milestones, ordinary progress/i)
+    expect(send).toMatch(/accepts no Agent Session id/i)
+    expect(send).toMatch(/active harness proves the exact current Agent Session/i)
   })
 
   it('never teaches by enumerating environments the CLI can detect itself', () => {
@@ -247,7 +252,7 @@ describe('Notifai agent skill', () => {
     // Harness names may appear only in setup/routing material, where the
     // harness IS the subject.
     for (const heading of ['## Decide whether to notify', '## Send', '## Ask a question', '## When the answer arrives']) {
-      expect(section(heading), heading).not.toMatch(/OpenCode|Orca|Cursor|Codex/)
+      expect(section(heading), heading).not.toMatch(/OpenCode|Orca|Cursor|Codex|Hermes/)
     }
   })
 
@@ -383,6 +388,7 @@ describe('Notifai agent skill', () => {
       'notifai guidance',
       'notifai logs',
       'notifai status',
+      'notifai sounds',
     ]) {
       expect(skill, `${command} is unreachable from the skill`).toContain(command)
     }
@@ -391,9 +397,14 @@ describe('Notifai agent skill', () => {
   it('moves per-harness mechanics into progressive disclosure', () => {
     expect(skill).toContain('[Harness setup and recovery](references/harness-setup.md)')
     expect(skill).toMatch(/read it when you are\s+installing hooks or diagnosing routing/i)
-    for (const harness of ['Claude Code', 'Codex', 'Cursor', 'OpenCode']) {
+    for (const harness of ['Claude Code', 'Codex', 'Cursor', 'OpenCode', 'Hermes']) {
       expect(harnessReference).toContain(`**${harness}:**`)
     }
+    expect(harnessReference).toMatch(/exact `HERMES_SESSION_ID`/i)
+    expect(harnessReference).toMatch(/Do not run `notifai hooks install --harness hermes`/i)
+    expect(harnessReference).toMatch(/blocking `notifai send --reply`/i)
+    expect(harnessReference).toMatch(/npx skills/i)
+    expect(harnessReference).toMatch(/no Hermes plugin may vendor/i)
     // The agent runs what a process can run; the human only does the human part.
     expect(harnessReference).toMatch(/let init install and assess\s+the hooks/i)
     expect(harnessReference).toContain('--setup-scope <project|global>')