src/express/agent.test.ts

@@ -87,6 +87,53 @@ describe('instruction agent', () => {
   })
 })
 
+describe('instruction agent with vague or long instructions', () => {
+  const LONG = `Buat 5 konten pembelajaran baru bertema Management Skills setiap hari secara otomatis pada pukul 09.00 WIB.
+
+Gunakan seluruh materi pembelajaran yang tersedia di dalam sistem sebagai referensi. Pastikan setiap konten memiliki topik yang berbeda, relevan, informatif, dan tidak menduplikasi konten yang sudah pernah dibuat.
+
+Simpan seluruh konten yang berhasil dibuat ke dalam sistem dengan status Draft untuk ditinjau oleh admin sebelum dipublikasikan.
+
+Jalankan proses ini menggunakan scheduler atau background job yang tersedia di sistem.`
+
+  it('reads a long brief as one rule and answers the rest truthfully instead of asking about it', () => {
+    const turn = respond(EMPTY, LONG)
+    expect(rules(turn.state)).toEqual([expect.objectContaining({ count: 5, per: 'day', topic: 'Management Skills', kindGuessed: true })])
+    expect(turn.state.unknown).toEqual([])
+    for (const key of ['note.draft', 'note.novelty', 'note.automatic', 'note.wholeBrain'] as const) expect(turn.reply).toContain(t(key))
+    expect(turn.reply).toContain(t('note.hourMatches', { at: '09.00' }))
+    expect(nextQuestion(turn.state)?.type).toBe('kind')
+  })
+
+  it('asks which kind "content" means, and splits the count over the kinds named', () => {
+    const s = say(LONG, 'ringkasan dan kuis')
+    expect(rules(s)).toMatchObject([{ kind: 'summary', count: 3 }, { kind: 'quiz', count: 2 }])
+    expect(rules(say(LONG, t('agent.optMix'))).map(r => r.type === 'content' && r.kind)).toEqual(['summary', 'quiz', 'flashcards'])
+  })
+
+  it('asks how often instead of assuming per week', () => {
+    const s = say('bikin 10 konten baru dalam 20 menit', 'kuis')
+    expect(nextQuestion(s)?.type).toBe('per')
+    expect(rules(say('bikin 10 konten baru dalam 20 menit', 'kuis', t('agent.optEveryWeek')))[0]).toMatchObject({ kind: 'quiz', count: 10, per: 'week', perGuessed: undefined })
+  })
+
+  it('says plainly that it cannot work in minutes', () => {
+    expect(respond(EMPTY, 'bikin 10 konten baru dalam 20 menit').reply).toContain(t('note.subDay'))
+  })
+
+  it('replaces the placeholder when the user restates the request, rather than adding another', () => {
+    const s = say('10 pdf per day', '10 konten')
+    expect(rules(s)).toHaveLength(1)
+    expect(rules(s)[0]).toMatchObject({ count: 10, per: 'day', kindGuessed: true })
+  })
+
+  it('does not repeat the same question when a rephrasing still makes no sense', () => {
+    const s = say('2 summaries per day about sales. hello there', 'blabla')
+    expect(s.unknown).toEqual([])
+    expect(nextQuestion(s)?.type).toBe('language')
+  })
+})
+
 describe('chatLangOf', () => {
   it('tells Indonesian from English, and stays undecided on short replies', () => {
     expect(chatLangOf('Saya mau buat video dari file LLM')).toBe('id')

src/express/agent.ts

@@ -4,8 +4,8 @@
 // user to spot alone.
 import { t, type Key, type Lang } from '../i18n'
 import {
-  dayName, describeRule, LANGUAGES, languageLabel, languageOf, parseInstruction, videoCadence, weekdayOf, weeklyTarget,
-  type ContentRule, type OutputLanguage, type ResearchRule, type Rule,
+  dayName, describeRule, KINDS, kindLabel, kindsIn, LANGUAGES, languageLabel, languageOf, parseInstruction, videoCadence, weekdayOf,
+  weeklyTarget, type ContentKind, type ContentRule, type Note, type OutputLanguage, type ResearchRule, type Rule,
 } from './parse'
 
 export interface Item { id: number; rule: Rule }
@@ -26,13 +26,20 @@ export const EMPTY: AgentState = { items: [], unknown: [], settled: [], language
 
 export type Question =
   | { key: string; type: 'unknown'; text: string }
-  | { key: string; type: 'video' | 'tooMany' | 'weekday'; id: number }
+  | { key: string; type: 'kind' | 'video' | 'tooMany' | 'weekday'; id: number }
   | { key: string; type: 'topic'; ids: number[] }
+  | { key: string; type: 'per'; ids: number[] }
   | { key: string; type: 'language' }
 
 /** What the plan still needs, in the order the agent asks about it. */
 export function nextQuestion(s: AgentState): Question | null {
   if (s.unknown.length) return { key: `unknown:${s.unknown[0]}`, type: 'unknown', text: s.unknown[0] }
+  // The kind and the frequency come first: the other checks depend on them.
+  const generic = s.items.find(i => i.rule.type === 'content' && i.rule.kindGuessed)
+  if (generic) return { key: `kind:${generic.id}`, type: 'kind', id: generic.id }
+  // One question for every rule with no frequency, since they usually come from the same request.
+  const unset = s.items.filter(i => i.rule.type === 'content' && i.rule.perGuessed).map(i => i.id)
+  if (unset.length) return { key: `per:${unset.join(',')}`, type: 'per', ids: unset }
   for (const { id, rule } of s.items) {
     if (rule.type === 'content' && rule.kind === 'video' && videoCadence(rule) === null) return { key: `video:${id}`, type: 'video', id }
     if (rule.type === 'content' && rule.kind !== 'video' && weeklyTarget(rule) > 50) return { key: `tooMany:${id}`, type: 'tooMany', id }
@@ -51,12 +58,27 @@ const describe = (s: AgentState, rule: Rule) => describeRule(rule, s.sources ??
 const bullets = (s: AgentState, rules: Rule[]) => rules.map(r => `• ${describe(s, r)}`).join('\n')
 const about = (rule: Rule) => (rule.topic ? t('rule.about', { topic: rule.topic }) : '')
 const ruleById = (s: AgentState, id: number) => s.items.find(i => i.id === id)!.rule
+const contentById = (s: AgentState, id: number) => ruleById(s, id) as ContentRule
+// "Mix" splits a generic request over the three kinds most teams start with.
+const MIX: ContentKind[] = ['summary', 'quiz', 'flashcards']
 
 /** The agent's question, with replies the user can pick instead of typing. */
 export function ask(q: Question, s: AgentState): { text: string; options: string[] } {
   switch (q.type) {
     case 'unknown':
       return { text: t('agent.askUnknown', { part: q.text }), options: [t('agent.optSkip')] }
+    case 'kind': {
+      const rule = contentById(s, q.id)
+      return {
+        text: t('agent.askKind', { count: rule.count, about: about(rule) }),
+        options: [...KINDS.map(kindLabel), t('agent.optMix')],
+      }
+    }
+    case 'per':
+      return {
+        text: t('agent.askPer', { list: bullets(s, q.ids.map(id => ruleById(s, id))) }),
+        options: [t('agent.optEveryDay'), t('agent.optEveryWeek')],
+      }
     case 'video':
       return { text: t('agent.askVideo', { rule: describe(s, ruleById(s, q.id)) }), options: [t('agent.optPerWeek'), t('agent.optPerDay'), t('agent.optRemove')] }
     case 'tooMany':
@@ -79,6 +101,8 @@ export function editRule(s: AgentState, id: number, patch: Partial<ContentRule>
     // A count or frequency typed in by hand replaces the monthly request it was derived from.
     ...('count' in patch || 'per' in patch ? { monthly: undefined } : {}),
     ...('weekday' in patch || 'cadence' in patch ? { weekdayGuessed: undefined } : {}),
+    ...('kind' in patch ? { kindGuessed: undefined } : {}),
+    ...('per' in patch ? { perGuessed: undefined } : {}),
   }
   return { ...s, items: s.items.map(i => (i.id === id ? { ...i, rule: { ...i.rule, ...patch, ...guessed } as Rule } : i)) }
 }
@@ -88,10 +112,11 @@ export const removeRule = (s: AgentState, id: number): AgentState => ({ ...s, it
 // Words that tell which language a message is written in, so the agent can answer in it.
 const ID_CHAT = new Set(('saya aku mau ingin bikin bikinin buat buatkan tolong dong ya iya tidak gak nggak enggak yang dan dengan untuk dari '
   + 'ke di ini itu apa bagaimana gimana hari minggu bulan setiap tiap soal tentang mengenai riset ringkasan kuis lewati hapus seluruh '
-  + 'otak senin selasa rabu kamis jumat sabtu sip lanjut bahasa pakai jadi kalau kalo juga aja saja sekarang mulai').split(' '))
+  + 'otak senin selasa rabu kamis jumat sabtu sip lanjut bahasa pakai jadi kalau kalo juga aja saja sekarang mulai konten baru materi '
+  + 'pembelajaran menit jam dalam simpan gunakan pastikan').split(' '))
 const EN_CHAT = new Set(('i me my want would like make create please the and with for from to in this that what how day week month every '
   + 'each about research summary summaries quiz quizzes skip remove whole brain monday tuesday wednesday thursday friday saturday '
-  + 'sunday yes no okay sure start use language also just now').split(' '))
+  + 'sunday yes no okay sure start use language also just now content new minutes hours save make sure').split(' '))
 
 /** The language a message is written in, or null when it is too short or mixed to tell. */
 export function chatLangOf(text: string): Lang | null {
@@ -109,19 +134,72 @@ const REMOVE = /^(remove|hapus|buang|delete)\b/
 const WHOLE = /^(whole brain|the whole brain|seluruh otak|semua|semuanya|all|everything|apa saja|bebas)$/
 const DAILY = /\b(per ?hari|tiap hari|setiap hari|sehari|harian|per day|a day|every day|each day|daily)\b/
 const WEEKLY = /\b(per ?minggu|tiap minggu|setiap minggu|seminggu|mingguan|per week|a week|every week|each week|weekly)\b/
+const MONTHLY = /\b(per ?bulan|tiap bulan|setiap bulan|sebulan|bulanan|per month|a month|every month|each month|monthly)\b/
+const MIX_REPLY = /^(campur|campuran|mix|mixed|bebas|terserah|apa saja|any)\b/
 
 let seq = 0
 const withIds = (rules: Rule[]) => rules.map(rule => ({ id: ++seq, rule }))
 
-// A new instruction: its rules join the plan and its unclear parts are queued as questions.
+const noteText = (notes: Note[]) => notes.map(n => `\n${t(n.key, n.vars)}`).join('')
+
+// A new instruction: its rules join the plan and its unclear parts are queued as questions. Requests about
+// how schedules run (drafts, the hour, "automatically") get a truthful note instead of being ignored.
 function instruct(s: AgentState, text: string): Turn | null {
-  const { rules, unknown, language } = parseInstruction(text)
-  const languageNote = language ? `\n${t('agent.languageSet', { language: languageLabel(language) })}` : ''
-  if (!rules.length) return language ? { state: { ...s, language }, reply: languageNote.trim() } : null
-  return {
-    state: { ...s, items: [...s.items, ...withIds(rules)], unknown: [...s.unknown, ...unknown], language: language ?? s.language },
-    reply: t(s.items.length ? 'agent.added' : 'agent.understood', { list: bullets(s, rules) }) + languageNote,
+  const { rules, unknown, language, notes } = parseInstruction(text)
+  const extra = (language ? `\n${t('agent.languageSet', { language: languageLabel(language) })}` : '') + noteText(notes)
+  if (!rules.length) return extra ? { state: { ...s, language: language ?? s.language }, reply: extra.trim() } : null
+  let state: AgentState = { ...s, items: [...s.items, ...withIds(rules)], unknown: [...s.unknown, ...unknown], language: language ?? s.language }
+  // "Gunakan seluruh materi" already answers the topic question with the whole Brain.
+  const q = nextQuestion(state)
+  if (q?.type === 'topic' && notes.some(n => n.key === 'note.wholeBrain')) state = { ...state, settled: [...state.settled, q.key] }
+  return { state, reply: t(s.items.length ? 'agent.added' : 'agent.understood', { list: bullets(s, rules) }) + extra }
+}
+
+// A placeholder rule becomes the rules the reply asks for, in its place in the plan.
+function replaceRule(s: AgentState, id: number, rules: Rule[], notes: Note[] = []): Turn {
+  const at = s.items.findIndex(i => i.id === id)
+  const items = [...s.items.slice(0, at), ...withIds(rules), ...s.items.slice(at + 1)]
+  return { state: { ...s, items }, reply: t('agent.kindSet', { list: bullets(s, rules) }) + noteText(notes) }
+}
+
+// "Ringkasan dan kuis" for "10 konten" splits the count: 5 summaries and 5 quizzes.
+function answerKind(s: AgentState, id: number, text: string, lower: string, mix: boolean): Turn | null {
+  const rule = contentById(s, id)
+  // A full instruction ("2 ringkasan per hari", or "10 konten" again) restates the request, so it
+  // replaces the placeholder instead of adding a second one; what it leaves out is kept from before.
+  if (/\d/.test(lower)) {
+    const { rules: parsed, notes } = parseInstruction(text)
+    if (!parsed.length) return null
+    return replaceRule(s, id, parsed.map(r => {
+      if (r.type === 'research') return r.topic ? r : { ...r, topic: rule.topic }
+      const keepPer = r.perGuessed && !rule.perGuessed ? { per: rule.per, perGuessed: undefined } : {}
+      return { ...r, topic: r.topic || rule.topic, ...keepPer }
+    }), notes)
   }
+  const kinds = mix ? MIX : [...new Set([...kindsIn(lower), ...KINDS.filter(k => lower === kindLabel(k).toLowerCase())])]
+  if (!kinds.length) return null
+  const { kindGuessed: _, ...base } = rule
+  return replaceRule(s, id, kinds.map((kind, i) => ({
+    ...base,
+    kind,
+    count: Math.max(1, Math.floor(rule.count / kinds.length) + (i < rule.count % kinds.length ? 1 : 0)),
+  })))
+}
+
+// "Per hari" sets the frequency of every rule asked about; a number ("5 per hari") only when there is one.
+function answerPer(s: AgentState, ids: number[], lower: string): Turn | null {
+  // A reply naming a kind or research is a new request, not a frequency for these.
+  if (kindsIn(lower).length || /\b(riset|research)\b/.test(lower)) return null
+  const n = ids.length === 1 ? Number(lower.match(/\d+/)?.[0]) || null : null
+  const monthly = MONTHLY.test(lower) || /\b(bulan|month)\b/.test(lower)
+  const per = monthly || WEEKLY.test(lower) || /\b(minggu|week)\b/.test(lower) ? 'week'
+    : DAILY.test(lower) || /\b(hari|day)\b/.test(lower) ? 'day' : null
+  if (!per) return null
+  const state = ids.reduce((st, id) => {
+    const count = n ?? contentById(st, id).count
+    return editRule(st, id, { per, count: monthly ? Math.max(1, Math.round(count / 4)) : count })
+  }, s)
+  return { state, reply: t('agent.kindSet', { list: bullets(state, ids.map(id => ruleById(state, id))) }) }
 }
 
 // A reply to the language question may be short ("indo", "inggris", "zh"), so it is read more loosely.
@@ -157,9 +235,11 @@ function answer(q: Question, s: AgentState, text: string, lower: string, is: (k:
     return { state: q.ids.reduce((st, id) => editRule(st, id, { topic }), s), reply: t('agent.topicSet', { topic }) }
   }
 
+  if (q.type === 'per') return answerPer(s, q.ids, is('agent.optEveryDay') ? 'per hari' : is('agent.optEveryWeek') ? 'per minggu' : lower)
   if (REMOVE.test(lower) || is('agent.optRemove')) {
     return { state: removeRule(s, q.id), reply: t('agent.removed', { rule: describe(s, ruleById(s, q.id)) }) }
   }
+  if (q.type === 'kind') return answerKind(s, q.id, text, lower, MIX_REPLY.test(lower) || is('agent.optMix'))
   const per = DAILY.test(lower) || /\b(hari|day)\b/.test(lower) ? 'day' : WEEKLY.test(lower) || /\b(minggu|week)\b/.test(lower) ? 'week' : null
   if (q.type === 'video') return per ? updated(s, q.id, { count: 1, per }) : null
   if (q.type === 'tooMany') {
@@ -182,8 +262,13 @@ export function respond(s: AgentState, input: string): Turn {
 
   const q = nextQuestion(s)
   if (q) {
-    // Not an answer, so maybe a new instruction; otherwise the same question is asked again.
-    return answer(q, s, text, lower, is) ?? instruct(s, text) ?? { state: s, reply: t('agent.unclear') }
+    const turn = answer(q, s, text, lower, is) ?? instruct(s, text)
+    if (turn) return turn
+    // A rephrasing that still made no sense: asking about the old wording again would loop, so it is
+    // dropped and the agent says what it can do instead.
+    if (q.type === 'unknown') return { state: { ...s, unknown: s.unknown.slice(1) }, reply: t('agent.notUnderstood') }
+    // Otherwise the same question is asked again.
+    return { state: s, reply: t('agent.unclear') }
   }
   if (s.items.length && (YES.test(lower) || is('agent.optApprove'))) return { state: s, reply: '', approve: true }
   return instruct(s, text) ?? { state: s, reply: t('agent.notUnderstood') }

src/express/parse.test.ts

@@ -78,3 +78,26 @@ describe('counts', () => {
     expect(parseInstruction('buat 0 ringkasan per minggu').rules[0]).toMatchObject({ kind: 'summary', count: 1 })
   })
 })
+
+describe('generic content and sentences', () => {
+  it('reads "konten" and "pdf" with a count as content of a kind still to choose', () => {
+    expect(content('10 pdf per day')[0]).toMatchObject({ kind: 'summary', count: 10, per: 'day', kindGuessed: true })
+    expect(content('bikin konten tiap minggu soal sales')[0]).toMatchObject({ kindGuessed: true, topic: 'sales' })
+  })
+
+  it('does not read "gunakan seluruh materi" as a request', () => {
+    expect(parseInstruction('gunakan seluruh materi pembelajaran sebagai referensi').rules).toEqual([])
+  })
+
+  it('marks a rule with no frequency instead of silently making it weekly', () => {
+    expect(content('3 kuis soal sales')[0]).toMatchObject({ per: 'week', perGuessed: true })
+    expect(content('3 kuis per minggu soal sales')[0].perGuessed).toBeUndefined()
+  })
+
+  it('does not end a sentence inside a time such as 09.00', () => {
+    const { rules, unknown } = parseInstruction('buat 2 kuis tiap hari soal sales pada pukul 09.00 WIB. simpan sebagai draft')
+    expect(rules).toHaveLength(1)
+    expect(rules[0]).toMatchObject({ topic: 'sales' })
+    expect(unknown).toEqual([])
+  })
+})

src/express/parse.ts

@@ -30,6 +30,20 @@ const KIND_WORDS: [ContentKind, RegExp][] = [
   ['summary', /\b(summary|summaries|ringkasan|rangkuman|artikel|articles?|teks|texts?)\b/],
 ]
 
+/** Every content kind a text names, in the order it names them: "ringkasan dan kuis" → summary, quiz. */
+export function kindsIn(text: string): ContentKind[] {
+  return KIND_WORDS
+    .map(([kind, re]) => [kind, text.search(re)] as const)
+    .filter(([, at]) => at >= 0)
+    .sort((a, b) => a[1] - b[1])
+    .map(([kind]) => kind)
+}
+
+// "10 konten", "5 materi pembelajaran", "10 pdf": content of no particular kind, so the agent asks which.
+// Only with a count or a create verb before it, so "gunakan seluruh materi" is not a request.
+const GENERIC = /\b(konten|content|contents|materi|materials?|bahan ajar|pdf|pdfs|dokumen|documents?|modul|modules?|items?)\b/
+const CREATE = /\b(bikin|bikinin|buat|buatkan|membuat|hasilkan|produksi|make|create|generate|produce|write|tulis)\b/
+
 const NUMBER_WORDS: Record<string, number> = {
   satu: 1, se: 1, sebuah: 1, dua: 2, tiga: 3, empat: 4, lima: 5, enam: 6, tujuh: 7, delapan: 8, sembilan: 9, sepuluh: 10,
   a: 1, an: 1, one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10,
@@ -77,6 +91,10 @@ export interface ContentRule {
   language?: OutputLanguage
   /** Made from material chosen in the Brain panel rather than the whole Brain. */
   chosen?: boolean
+  /** The instruction said "content" without a kind, so the kind is only a placeholder the agent asks about. */
+  kindGuessed?: boolean
+  /** The instruction named no frequency, so per week is only a placeholder the agent asks about. */
+  perGuessed?: boolean
 }
 
 export interface ResearchRule {
@@ -91,37 +109,81 @@ export interface ResearchRule {
 
 export type Rule = ContentRule | ResearchRule
 
+/** Something the instruction asked for that is not a rule: the agent answers it truthfully instead of ignoring it. */
+export interface Note { key: Key; vars?: Record<string, string | number> }
+
 export interface ParseResult {
   rules: Rule[]
   /** Clauses that said something but matched no rule, so the user can rephrase them. */
   unknown: string[]
   /** The output language the instruction named. */
   language?: OutputLanguage
+  notes: Note[]
 }
 
+// Requests about how schedules work rather than what they make. Each is answered with what Express
+// actually does, so the agent neither ignores them nor promises something it cannot do.
+const META: [RegExp, Key | null][] = [
+  [/\b(?:seluruh|semua)\s+(?:materi|bahan|dokumen|otak|brain|isi)|\bwhole brain\b|\ball (?:the )?(?:materials?|documents?|brain)\b/, 'note.wholeBrain'],
+  [/duplika|duplicat|\b(?:tidak|jangan|tanpa|bukan)\s+(?:meng)?ulang|\b(?:without|not|don'?t|no)\s+repeat|\b(?:topik|topics?)\s+(?:yang\s+)?(?:berbeda|beda|different|unik|unique)|\bdifferent topics?\b/, 'note.novelty'],
+  [/\b(?:draf|draft|drafts|ditinjau|tinjau|peninjauan|reviews?|reviewed|approval|persetujuan|disetujui|dipublikasikan|publikasi|published?)\b/, 'note.draft'],
+  [/\b(?:scheduler|penjadwal|background|latar belakang|cron|otomatis|automatic(?:ally)?|terjadwal)\b/, 'note.automatic'],
+  // Wishes every schedule already aims for; nothing to add, but not a part the agent failed to understand.
+  [/\b(?:relevan|relevant|informatif|informative|berkualitas|bermanfaat|menarik|useful|engaging|quality|referensi|reference)\b/, null],
+]
+const HOUR = /\b(?:pukul|pkl|jam|at)\s*(\d{1,2})(?:[.:](\d{2}))?\s*(am|pm)?/
+const SUB_DAY = /\b\d+\s*(?:menit|jam|detik|minutes?|mins?|hours?|seconds?)\b|\b(?:tiap|setiap|per|every|each)\s+(?:menit|jam|minute|hour)\b|\bhourly\b/
+
+function notesOf(text: string): Note[] {
+  const notes: Note[] = META.flatMap(([re, key]) => (key && re.test(text) ? [{ key }] : []))
+  const hour = text.match(HOUR)
+  if (hour) {
+    let h = Number(hour[1])
+    if (hour[3] === 'pm' && h < 12) h += 12
+    if (hour[3] === 'am' && h === 12) h = 0
+    const at = `${String(h).padStart(2, '0')}.${hour[2] ?? '00'}`
+    notes.push({ key: at === '09.00' ? 'note.hourMatches' : 'note.hourFixed', vars: { at } })
+  }
+  if (SUB_DAY.test(text)) notes.push({ key: 'note.subDay' })
+  return notes
+}
+
+const isMeta = (clause: string) => META.some(([re]) => re.test(clause)) || HOUR.test(clause) || SUB_DAY.test(clause)
+
 // "dari file LLM" / "from the document onboarding" names a Brain file, which works as the topic.
-const TOPIC = /\b(?:soal|tentang|mengenai|seputar|terkait|topik|bertema|perihal|about|regarding|covering|related to|on the topic of|topic|(?:dari|from)(?: the)? (?:file|berkas|dokumen|documents?|materi|material))\s+(?!latihan\b)(.+)$/
-const FREQUENCY_TAIL = /\b(tiap|setiap|per|sehari|seminggu|every|each|daily|weekly|monthly|a day|a week|a month)\b.*$/
+const TOPIC = /\b(?:soal|tentang|mengenai|seputar|terkait|topik|bertema|perihal|about|regarding|covering|related to|on the topic of|topic|(?:dari|from)(?: the)? (?:file|berkas|dokumen|documents?|materi|material))\s+(?!latihan\b|yang\b)(.+)$/
+const FREQUENCY_TAIL = /\b(tiap|setiap|per|sehari|seminggu|every|each|daily|weekly|monthly|a day|a week|a month|pada pukul|pada jam|pukul|pkl|secara|otomatis|automatically|dalam \d|in \d|at \d)\b.*$/
 
 function topicOf(clause: string): string {
   return clause.match(TOPIC)?.[1].replace(FREQUENCY_TAIL, '').replace(/[\s,]+$/, '').trim() ?? ''
 }
 
-function countOf(clause: string, kindAt: number): number {
+/** The count right before a kind word, or null when the instruction named none. */
+function countBefore(clause: string, kindAt: number): number | null {
   const before = clause.slice(0, kindAt)
   const digits = before.match(/(\d+)\s*(?:buah|x|kali|new)?\s*$/)
   // "0" schedules nothing; the preview shows 1, which the user can still change.
   if (digits) return Math.max(1, Number(digits[1]))
   const word = before.match(/(\p{L}+)\s*(?:buah|new)?\s*$/u)?.[1]
-  return (word && NUMBER_WORDS[word]) || 1
+  return (word && NUMBER_WORDS[word]) || null
 }
 
+const countOf = (clause: string, kindAt: number) => countBefore(clause, kindAt) ?? 1
+
+const DAY_WORDS = /\b(per ?hari|tiap hari|setiap hari|sehari|harian|per day|a day|every day|each day|daily)\b/
+const WEEK_WORDS = /\b(per ?minggu|tiap minggu|setiap minggu|seminggu|mingguan|per week|a week|every week|each week|weekly)\b/
+const MONTH_WORDS = /\b(per ?bulan|tiap bulan|setiap bulan|sebulan|bulanan|per month|a month|every month|each month|monthly)\b/
+
 export function perOf(clause: string): Per | 'month' {
-  if (/\b(per ?hari|tiap hari|setiap hari|sehari|harian|per day|a day|every day|each day|daily)\b/.test(clause)) return 'day'
-  if (/\b(per ?bulan|tiap bulan|setiap bulan|sebulan|bulanan|per month|a month|every month|each month|monthly)\b/.test(clause)) return 'month'
+  if (DAY_WORDS.test(clause)) return 'day'
+  if (MONTH_WORDS.test(clause)) return 'month'
   return 'week'
 }
 
+/** Whether a clause says how often, rather than leaving perOf to fall back to per week. */
+export const namesFrequency = (clause: string) =>
+  DAY_WORDS.test(clause) || WEEK_WORDS.test(clause) || MONTH_WORDS.test(clause) || weekdayOf(clause) !== null
+
 export function weekdayOf(clause: string): number | null {
   for (const [re, day] of WEEKDAYS) if (re.test(clause)) return day
   return null
@@ -130,7 +192,8 @@ export function weekdayOf(clause: string): number | null {
 const CONNECTORS = 'dan|lalu|serta|terus|kemudian|juga|and|then|also|plus'
 // A connector or comma starts a new rule only when a new request follows; "about sales and marketing" stays one topic.
 const NEXT_REQUEST = String.raw`(?=(?:\d|satu|dua|tiga|empat|lima|enam|tujuh|delapan|sembilan|sepuluh|se(?:buah)?\s|one|two|three|four|five|six|seven|eight|nine|ten|an?\s|riset|research|bikin|buat|cari|telusuri|pantau|make|create|generate|search|monitor|tiap|setiap|every|each))`
-const SPLIT = new RegExp(String.raw`[\n.;]+|\s*,\s*(?:(?:${CONNECTORS})\s+)?${NEXT_REQUEST}|\s+(?:${CONNECTORS})\s+${NEXT_REQUEST}`)
+// A full stop ends a sentence, but not inside a time or number such as "09.00".
+const SPLIT = new RegExp(String.raw`(?:[\n;]|\.(?!\d))+|\s*,\s*(?:(?:${CONNECTORS})\s+)?${NEXT_REQUEST}|\s+(?:${CONNECTORS})\s+${NEXT_REQUEST}`)
 
 function parseClause(clause: string): Rule | null {
   if (/\b(riset|research|telusuri|cari(?:kan)?|pantau|look up|search|monitor)\b/.test(clause)) {
@@ -143,17 +206,25 @@ function parseClause(clause: string): Rule | null {
   }
   for (const [kind, re] of KIND_WORDS) {
     const m = re.exec(clause)
-    if (!m) continue
-    const count = countOf(clause, m.index)
-    const per = perOf(clause)
-    if (per === 'month') {
-      return { type: 'content', kind, count: Math.max(1, Math.round(count / 4)), per: 'week', topic: topicOf(clause), monthly: count }
-    }
-    return { type: 'content', kind, count, per, topic: topicOf(clause) }
+    if (m) return contentRule(clause, kind, countOf(clause, m.index))
+  }
+  const g = GENERIC.exec(clause)
+  if (g) {
+    const count = countBefore(clause, g.index)
+    if (count !== null || CREATE.test(clause.slice(0, g.index))) return { ...contentRule(clause, 'summary', count ?? 1), kindGuessed: true }
   }
   return null
 }
 
+function contentRule(clause: string, kind: ContentKind, count: number): ContentRule {
+  const per = perOf(clause)
+  const guessed = namesFrequency(clause) ? {} : { perGuessed: true }
+  if (per === 'month') {
+    return { type: 'content', kind, count: Math.max(1, Math.round(count / 4)), per: 'week', topic: topicOf(clause), monthly: count }
+  }
+  return { type: 'content', kind, count, per, topic: topicOf(clause), ...guessed }
+}
+
 export function parseInstruction(text: string): ParseResult {
   const language = languageOf(text)
   const clauses = text
@@ -170,6 +241,8 @@ export function parseInstruction(text: string): ParseResult {
   for (const clause of clauses) {
     const rule = parseClause(clause)
     if (rule) rules.push(rule)
+    // "simpan sebagai draft", "jalankan otomatis": answered as notes, not asked about.
+    else if (isMeta(clause)) continue
     // A clause that only names a topic ("about leadership") applies to the rules around it.
     else if (topicOf(clause) || /^(soal|tentang|topik|about|topic)\b/.test(clause)) shared = topicOf(clause) || clause.replace(/^\S+\s*/, '')
     else if (!/^(tolong|bikin|buat|buatkan|ya|please|make|create|ok)$/.test(clause)) unknown.push(clause)
@@ -187,7 +260,8 @@ export function parseInstruction(text: string): ParseResult {
       if (at >= 0) r.topic = text.slice(at, at + r.topic.length)
     }
   }
-  return language ? { rules, unknown, language } : { rules, unknown }
+  const notes = notesOf(text.toLowerCase())
+  return language ? { rules, unknown, language, notes } : { rules, unknown, notes }
 }
 
 export function weeklyTarget(rule: ContentRule): number {
@@ -209,10 +283,11 @@ export function describeRule(rule: Rule, from?: string): string {
     const when = rule.cadence === 'daily' ? t('rule.everyDay') : t('rule.everyWeekday', { day: dayName(rule.weekday) })
     return t('rule.research', { when, about })
   }
+  // A placeholder kind or frequency is shown as still open, not as if the user had chosen it.
   return t('rule.content', {
-    kind: kindLabel(rule.kind),
+    kind: rule.kindGuessed ? t('rule.anyKind') : kindLabel(rule.kind),
     count: rule.count,
-    per: t(rule.per === 'day' ? 'ins.perDay' : 'ins.perWeek'),
+    per: rule.perGuessed ? t('rule.perUnset') : t(rule.per === 'day' ? 'ins.perDay' : 'ins.perWeek'),
     about: about || (from ?? (rule.chosen ? t('rule.chosenMaterial') : null)
       ? t('rule.from', { source: from ?? t('rule.chosenMaterial') })
       : t('rule.wholeBrain')),

src/i18n.ts

@@ -178,6 +178,8 @@ const en = {
   'rule.wholeBrain': ' from the whole Brain',
   'rule.from': ' from {source}',
   'rule.chosenMaterial': 'chosen material',
+  'rule.anyKind': 'Content (kind not chosen yet)',
+  'rule.perUnset': '(how often not set yet)',
   'rule.content': '{kind}: {count} {per}{about}',
   'rule.monthNote': '{count} per month is scheduled as {weekly} per week.',
   'kind.summary': 'Summary',
@@ -327,7 +329,20 @@ const en = {
   'agent.greeting': 'Hi! Tell me what to create from the Brain and how often, or what to research on the internet. If anything is unclear, I will ask you here.',
   'agent.understood': 'Got it. Here is the plan so far:\n{list}',
   'agent.added': 'Added to the plan:\n{list}',
-  'agent.notUnderstood': 'I could not find a content type or research request in that. Try something like “2 summaries per day about leadership”.',
+  'agent.notUnderstood': 'I could not find a content type or research request in that. I can make summaries, quizzes, flashcards, roleplays, simulations, slides, videos, audio and SCORM modules from the Brain, or research the internet. Try something like “2 summaries per day about leadership”.',
+  'agent.askKind': '{count} pieces of content{about}: which kind? Pick one, or name several (for example “summaries and quizzes”) to split them.',
+  'agent.askPer': 'How often should this be made? You did not say, and I would rather not guess.\n{list}',
+  'agent.optMix': 'Mix (summaries, quizzes, flashcards)',
+  'agent.optEveryDay': 'Every day',
+  'agent.optEveryWeek': 'Every week',
+  'agent.kindSet': 'Updated the plan:\n{list}',
+  'note.wholeBrain': 'Sources: the whole Brain (every ready document), unless you tick specific material in the Brain panel.',
+  'note.novelty': 'Each production plan is checked against what was already made, so topics are not repeated.',
+  'note.draft': 'Everything made lands in Results as a draft marked “Needs review”: an admin approves or rejects it there before it is used.',
+  'note.automatic': 'Once you approve, the schedules run on their own in the background; nothing needs starting by hand.',
+  'note.hourMatches': 'Content is produced at {at} WIB, as you asked.',
+  'note.hourFixed': 'Content is produced at 09.00 WIB and research runs at 07.00 WIB; a different hour such as {at} cannot be set here yet.',
+  'note.subDay': 'Schedules run per day or per week, so I cannot promise results within minutes or hours. Once a schedule is active, “Produce now” on the Schedule page starts it early.',
   'agent.unclear': 'Sorry, I did not catch that. Pick one of the options below or answer in your own words.',
   'agent.askUnknown': 'I did not understand “{part}”. What did you mean? Rephrase it, or skip it.',
   'agent.askVideo': '{rule}: a video schedule makes one video per run, so it can be 1 per week or 1 per day. Which one?',
@@ -619,6 +634,8 @@ const id: Record<Key, string> = {
   'rule.wholeBrain': ' dari seluruh Otak',
   'rule.from': ' dari {source}',
   'rule.chosenMaterial': 'materi pilihan',
+  'rule.anyKind': 'Konten (jenis belum dipilih)',
+  'rule.perUnset': '(frekuensi belum ditentukan)',
   'rule.content': '{kind}: {count} {per}{about}',
   'rule.monthNote': '{count} per bulan dijadwalkan sebagai {weekly} per minggu.',
   'kind.summary': 'Ringkasan',
@@ -766,7 +783,20 @@ const id: Record<Key, string> = {
   'agent.greeting': 'Halo! Ceritakan konten apa yang perlu dibuat dari Otak dan seberapa sering, atau apa yang perlu diriset di internet. Kalau ada yang belum jelas, saya tanyakan di sini.',
   'agent.understood': 'Siap. Ini rencananya sejauh ini:\n{list}',
   'agent.added': 'Ditambahkan ke rencana:\n{list}',
-  'agent.notUnderstood': 'Saya belum menemukan jenis konten atau permintaan riset di situ. Coba misalnya “2 ringkasan per hari soal leadership”.',
+  'agent.notUnderstood': 'Saya belum menemukan jenis konten atau permintaan riset di situ. Saya bisa membuat ringkasan, kuis, flashcard, roleplay, simulasi, slide, video, audio, dan modul SCORM dari Otak, atau riset internet. Coba misalnya “2 ringkasan per hari soal leadership”.',
+  'agent.askKind': '{count} konten{about}: jenisnya apa? Pilih satu, atau sebut beberapa (misalnya “ringkasan dan kuis”) untuk membaginya.',
+  'agent.askPer': 'Seberapa sering ini dibuat? Anda belum menyebutkannya, dan saya tidak mau menebak.\n{list}',
+  'agent.optMix': 'Campuran (ringkasan, kuis, flashcard)',
+  'agent.optEveryDay': 'Setiap hari',
+  'agent.optEveryWeek': 'Setiap minggu',
+  'agent.kindSet': 'Rencana diperbarui:\n{list}',
+  'note.wholeBrain': 'Sumbernya seluruh Otak (semua dokumen yang siap), kecuali Anda mencentang materi tertentu di panel Otak.',
+  'note.novelty': 'Setiap rencana produksi dicek terhadap konten yang sudah ada, jadi topiknya tidak berulang.',
+  'note.draft': 'Semua hasil masuk ke Hasil sebagai draf berstatus “Perlu ditinjau”: admin menyetujui atau menolaknya di sana sebelum dipakai.',
+  'note.automatic': 'Setelah Anda setujui, jadwal berjalan sendiri di latar belakang; tidak perlu dijalankan manual.',
+  'note.hourMatches': 'Konten diproduksi pukul {at} WIB, sesuai permintaan.',
+  'note.hourFixed': 'Konten diproduksi pukul 09.00 WIB dan riset pukul 07.00 WIB; jam lain seperti {at} belum bisa diatur dari sini.',
+  'note.subDay': 'Jadwal berjalan per hari atau per minggu, jadi saya tidak bisa menjanjikan hasil dalam hitungan menit atau jam. Setelah jadwal aktif, tombol “Produksi sekarang” di halaman Jadwal memulainya lebih awal.',
   'agent.unclear': 'Maaf, saya belum menangkap maksudnya. Pilih salah satu opsi di bawah atau jawab dengan kata-kata sendiri.',
   'agent.askUnknown': 'Saya belum paham “{part}”. Maksudnya apa? Tulis ulang, atau lewati saja.',
   'agent.askVideo': '{rule}: jadwal video membuat satu video per proses, jadi pilihannya 1 per minggu atau 1 per hari. Mau yang mana?',