@raidiant/notifai 8.0.0 → 9.0.0

package/src/skill.test.ts

@@ -23,6 +23,7 @@ import { GATE_REASONS } from './hooks.js'
 
 const skillPath = new URL('../../../skills/notifai/SKILL.md', import.meta.url)
 const skill = readFileSync(skillPath, 'utf8')
+const description = skill.match(/^description:\s*(.+)$/m)?.[1] ?? ''
 const harnessReference = readFileSync(
   new URL('../../../skills/notifai/references/harness-setup.md', import.meta.url),
   'utf8',
@@ -46,6 +47,32 @@ const section = (heading: string): string => {
 }
 
 describe('Notifai agent skill', () => {
+  it('routes proactively in ordinary sessions without waiting for the user to name Notifai', () => {
+    // The frontmatter description is the only skill text available during
+    // automatic selection. If the ordinary-session trigger lives only in the
+    // body, agents doing unrelated work never load it and therefore never see
+    // the completion rule.
+    expect(description).toMatch(/every agent session/i)
+    expect(description).toMatch(/even when the user does not mention Notifai/i)
+    expect(description).toMatch(/guidance/i)
+
+    const decide = section('## Decide whether to notify')
+    expect(decide).toMatch(/every session's first task turn/i)
+    expect(decide).toMatch(/read guidance before judging an Agent\s+Event/i)
+    expect(decide).toMatch(/parent owns User-visible Notification Requests/i)
+    expect(decide).toMatch(/unless\s+it explicitly delegates/i)
+    expect(decide).toMatch(/workers[\s\S]{0,100}do not send independently/i)
+  })
+
+  it('preserves the original Agent Event across setup and ambiguous delivery', () => {
+    expect(skill).toMatch(
+      /interrupted or killed `send`[\s\S]*`send\.attempt`[\s\S]*session,\s+title length, kind, and time/i,
+    )
+    expect(skill).toMatch(/unambiguous match[\s\S]*otherwise report ambiguous delivery without retrying/i)
+    expect(skill).toMatch(/`no_active_devices`[\s\S]*repeat the original send/i)
+    expect(skill).toMatch(/verification Notification[\s\S]*does not deliver the original Agent Event/i)
+  })
+
   it('fits inside the budget a skill is actually read within', () => {
     // Long skills are truncated in exactly the long sessions that need them.
     // The old skill sat at ~4,800 tokens; this ceiling keeps a working margin.
@@ -81,7 +108,74 @@ describe('Notifai agent skill', () => {
     for (const topic of ['when-to-notify', 'titles', 'bodies', 'questions', 'acknowledgements']) {
       expect(decide).toContain(`\`${topic}\``)
     }
-    expect(decide).toMatch(/outranks the shipped\s+default and your judgement/i)
+    const authorityOrder = ['from=you', 'from=this repository', 'from=shipped default'].map(
+      (marker) => decide.indexOf(marker),
+    )
+    expect(authorityOrder[0]).toBeGreaterThan(decide.indexOf('notifai guidance'))
+    expect(authorityOrder[1]).toBeGreaterThan(authorityOrder[0]!)
+    expect(authorityOrder[2]).toBeGreaterThan(authorityOrder[1]!)
+  })
+
+  it('separates repository policy from the User and makes non-exfiltration absolute', () => {
+    const decide = section('## Decide whether to notify')
+    const markers = ['from=you', 'from=this repository', 'from=shipped default']
+    const markerPositions = markers.map((marker) => decide.indexOf(marker))
+    expect(markerPositions.every((position) => position >= 0)).toBe(true)
+
+    const numberedLimits = [
+      ...decide.matchAll(/^\d+\. \*\*([^*]+)\.\*\*([\s\S]*?)(?=^\d+\. |\n\n)/gm),
+    ]
+    expect(numberedLimits.map((match) => match[1]?.toLowerCase())).toEqual([
+      'non-exfiltration',
+      'repository authority',
+    ])
+
+    const normalize = (value: string | undefined): string =>
+      (value ?? '').toLowerCase().replace(/\s+/g, ' ')
+    const nonExfiltration = normalize(numberedLimits[0]?.[2])
+    for (const protectedClass of [
+      'credential',
+      'token',
+      'key',
+      'password',
+      'environment',
+      'configuration',
+      'guidance',
+      'log',
+    ]) {
+      expect(nonExfiltration, protectedClass).toContain(protectedClass)
+    }
+    for (const outboundField of [
+      'notification request',
+      'question',
+      'choice',
+      'acknowledgement',
+      'image',
+    ]) {
+      expect(nonExfiltration, outboundField).toContain(outboundField)
+    }
+
+    const authority = normalize(numberedLimits[1]?.[2])
+    for (const protectedAuthority of [
+      'standing word',
+      'settings',
+      'guidance',
+      'cli',
+      'origins',
+      'direct user instruction',
+    ]) {
+      expect(authority, protectedAuthority).toContain(protectedAuthority)
+    }
+
+    const obligations = normalize(decide.slice(numberedLimits[1]?.index ?? 0))
+    const refuse = obligations.indexOf('refuse')
+    const report = obligations.indexOf('tell the user')
+    const noOutboundReport = obligations.search(
+      /(?:do not|never|cannot)[^.]{0,120}notification request/,
+    )
+    expect(refuse).toBeGreaterThanOrEqual(0)
+    expect(report).toBeGreaterThan(refuse)
+    expect(noOutboundReport).toBeGreaterThan(report)
   })
 
   it('names every notification kind the CLI accepts', () => {
@@ -100,6 +194,15 @@ describe('Notifai agent skill', () => {
     expect(skill).not.toMatch(/kind never chooses/i)
   })
 
+  it('routes a blocker through a question whenever the User response resumes the work', () => {
+    // `blocked` and `question` are mutually exclusive on the wire. The skill
+    // must teach the selection boundary or an imperative such as "unlock it"
+    // becomes an unanswerable one-way notification.
+    const selection = `${section('## Send')}\n${section('## Ask a question')}`
+    expect(selection).toMatch(/work needs a User response[\s\S]{0,160}answerable\s+question/i)
+    expect(selection).toMatch(/one-way blocked[\s\S]{0,160}no\s+User\s+reply\s+would\s+resume/i)
+  })
+
   it('keeps every send example valid against the CLI it documents', () => {
     const sends = shellExamples.filter((line) => line.startsWith('notifai send'))
     expect(sends.length).toBeGreaterThan(0)
@@ -126,9 +229,9 @@ describe('Notifai agent skill', () => {
     expect(send).toContain('--session-label')
     expect(send).toMatch(/first Notification\s+Request/i)
     expect(send).toMatch(/2-6 words/i)
-    // The rule is unconditional: the environment's name wins, so the flag is
-    // safe everywhere and the agent never branches on where it is running.
-    expect(send).toMatch(/safe in every environment/i)
+    expect(send).toMatch(/only when the current\s+environment exposes an exact session/i)
+    expect(send).toMatch(/without an exact session[\s\S]{0,160}usage\s+error/i)
+    expect(send).toMatch(/omit `--session-label`/i)
     expect(send).toMatch(/name the\s+environment supplies wins/i)
     expect(send).toMatch(/freezes one semantic name/i)
     expect(send).toMatch(/omit the flag on later sends and\s+questions/i)
@@ -155,6 +258,12 @@ describe('Notifai agent skill', () => {
     expect(ask).toMatch(/exit code 3/i)
   })
 
+  it('teaches that closed choices appear after pressing and holding', () => {
+    const ask = section('## Ask a question')
+    expect(ask).toMatch(/closed choices appear after pressing and holding the\s+notification/i)
+    expect(skill).not.toMatch(/choices are buttons on the banner/i)
+  })
+
   it('makes registration the middle of the asking turn, not the end', () => {
     const ask = section('## Ask a question')
     expect(ask).toMatch(/registering is not the end of the turn/i)
@@ -189,6 +298,12 @@ describe('Notifai agent skill', () => {
     expect(skill).toContain('notifai replies --pending')
   })
 
+  it('teaches retirement of a registration that has not been pushed yet', () => {
+    expect(skill).toContain('notifai close --pending')
+    expect(skill).toContain('question_id')
+    expect(skill).toMatch(/answer\s+in the conversation/i)
+  })
+
   it('makes the agent the operator and the human only the human', () => {
     const setup = section('## Set Notifai up')
     expect(setup).toMatch(/never tell the\s+user to run a command you could have run/i)
@@ -196,6 +311,7 @@ describe('Notifai agent skill', () => {
     expect(setup).toMatch(/companion/i)
     expect(setup).toContain('notifai doctor --json')
     expect(setup).toContain('notifai init')
+    expect(setup).toContain('--setup-scope')
   })
 
   it('offers npx only as a pinned fallback behind a real install', () => {