diff --git a/CHANGELOG.md b/CHANGELOG.md
index 128ddd93..422c66ef 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,11 @@ Mọi thay đổi đáng kể của `8sync` ghi vào đây. Format theo [Keep a
 versioning theo [SemVer](https://semver.org). **8sync rule:** mỗi PR cập nhật mục `Unreleased`.
 
 ## [Unreleased]
+### Added
+- **Realtime hints inside Claude Code (`8sync ccc hint` + mod `8sync-hints`).** Owner (2026-10-16): "enhance prompt in ccc can auto hint real time like omp suggestion to tab completion". The kit now installs a Claude Code function-hooks mod at `~/.claude/skills/8sync-hints` (auto-loaded; open sessions need a restart) that draws three things from one local Rust call: **ghost text** for the next prompt (Tab/→ takes it: "tiếp tục loop <slug> (iter k/N)", own urgent flag, the prompt the owner typed after this one before — a bigram over `~/.claude/history.jsonl` filtered by project, local-only — then "/sec rồi commit" or "push nhánh … rồi mở PR" from git), **typeahead** rows with descriptions for `/skill` (installed + repo skills), `8sync <cmd>` and `8sync ccc <verb>` / `ccc <verb>` tokens, and a dim **band above the prompt** (≤ 2 lines: loop · branch ↑ahead ✎dirty · urgent · watchdog alert < 10 min) with an "Ẩn" button. The mod only calls `8sync ccc hint [--complete <token>] --json` (no network, no model, no `gh`; one `git status` with a 300 ms budget, run beside the prompt; silent when `8sync` is missing) — idea ported from omp's predictive composer, code ours. Tests: `hint_*` (Rust; < 50 ms without git on a 41-skill + 512 KiB-history fixture), `claude plugin validate|test` (8 mod tests), `kit_installs_the_hints_mod`, `scripts/uat/hints-load.sh`.
+- **`8sync completions <bash|zsh|fish|powershell|elvish>`**: shell tab-completion scripts generated from the same clap tree the binary parses (`8sync completions bash > ~/.local/share/bash-completion/completions/8sync`).
+- `research/omp-features.md`: scan of omp 18.11.1 features (MIT; ideas only) with what ccc already has, what this batch ports and what is queued for later.
+
 
 ## [0.92.1] — 2026-10-15
 ### Fixed
diff --git a/Cargo.lock b/Cargo.lock
index 26dd4ff5..5d3864f8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -230,6 +230,15 @@ dependencies = [
  "terminal_size",
 ]
 
+[[package]]
+name = "clap_complete"
+version = "4.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be2ad0423bdbbb0e25bc89add796f3559706d4a95e1bc98e4d9662a957b6a19"
+dependencies = [
+ "clap",
+]
+
 [[package]]
 name = "clap_derive"
 version = "4.6.1"
@@ -1404,6 +1413,7 @@ dependencies = [
  "axum",
  "ccc-core",
  "clap",
+ "clap_complete",
  "dirs",
  "getrandom 0.2.17",
  "indoc",
diff --git a/assets/claude/skills/8sync-hints/.claude-plugin/plugin.json b/assets/claude/skills/8sync-hints/.claude-plugin/plugin.json
new file mode 100644
index 00000000..76639ad3
--- /dev/null
+++ b/assets/claude/skills/8sync-hints/.claude-plugin/plugin.json
@@ -0,0 +1,7 @@
+{
+  "name": "8sync-hints",
+  "version": "0.1.0",
+  "author": { "name": "8 Sync", "url": "https://github.com/8-Sync-Dev/su-code" },
+  "description": "Gợi ý realtime trong prompt của Claude Code từ 8sync ccc hint: ghost text (Tab), typeahead /skill · 8sync · ccc, dải trạng thái trên prompt. Local-only.",
+  "types": "./types/index.d.ts"
+}
diff --git a/assets/claude/skills/8sync-hints/hooks/hint.test.ts b/assets/claude/skills/8sync-hints/hooks/hint.test.ts
new file mode 100644
index 00000000..7c4e87fa
--- /dev/null
+++ b/assets/claude/skills/8sync-hints/hooks/hint.test.ts
@@ -0,0 +1,147 @@
+import { expect, mock, test } from 'claude-code/testing'
+
+import { completeArg, parseComplete, parseHint } from './hint'
+
+const ok = (stdout: string) => ({ value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } })
+
+test('parseHint reads suggest + band and drops junk', async () => {
+  expect(parseHint('{"suggest":" tiếp tục loop x (iter 1/2) ","band":["loop x 1/2","⎇ main","three"]}')).toEqual({
+    suggest: 'tiếp tục loop x (iter 1/2)',
+    band: ['loop x 1/2', '⎇ main'],
+  })
+  expect(parseHint('{"suggest":null,"band":[]}')).toEqual({ suggest: null, band: [] })
+  expect(parseHint('')).toBe(null)
+  expect(parseHint('not json')).toBe(null)
+  expect(parseHint(null)).toBe(null)
+  expect(parseHint('[1]')).toBe(null)
+})
+
+test('parseComplete keeps well-formed rows only, at most 8', async () => {
+  const rows = Array.from({ length: 10 }, (_, i) => ({ text: `/s${i}`, label: `s${i}`, description: `d${i}` }))
+  const out = parseComplete(JSON.stringify({ complete: [...rows, { text: '' }, { label: 'no text' }, 7] }))
+  expect(out.length).toBe(8)
+  expect(out[0]).toEqual({ text: '/s0', label: 's0', description: 'd0' })
+  expect(parseComplete('{"complete":"x"}')).toEqual([])
+  expect(parseComplete(undefined)).toEqual([])
+})
+
+test('completeArg: slash token (not a path, not at the box start), 8sync/ccc lines, nothing else', async () => {
+  expect(completeArg('/sh', 3, '/sh')).toBe('/sh')
+  expect(completeArg('fix it then /sh', 15, '/sh', 12)).toBe('/sh')
+  expect(completeArg('/sh', 3, '/sh', 0)).toBe(null)
+  expect(completeArg('see /home/me/x', 14, '/home/me/x', 4)).toBe(null)
+  expect(completeArg('x /a:b.c-d', 10, '/a:b.c-d', 2)).toBe('/a:b.c-d')
+  expect(completeArg('8sync ccc lo', 12, 'lo')).toBe('8sync ccc lo')
+  expect(completeArg('run\n  ccc lo', 12, 'lo')).toBe('ccc lo')
+  expect(completeArg('8sync', 5, '8sync')).toBe('8sync')
+  expect(completeArg('please run 8sync ccc lo', 23, 'lo')).toBe(null)
+  expect(completeArg('hello', 5, 'hello')).toBe(null)
+})
+
+test('session.start asks 8sync ccc hint beside the start and proposes its suggestion', async ($, on) => {
+  const clock = mock.clock(on)
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  let argv: readonly string[] = []
+  let cwd: string | undefined
+  let env: Record<string, string> | undefined
+  on('session.id', () => ({ value: 'sess-1' }))
+  on('process.run', (_$, e) => {
+    argv = e.argv
+    cwd = e.init?.cwd
+    env = e.init?.env
+    return ok('{"suggest":"tiếp tục loop x (iter 1/2)","band":["loop x 1/2"]}')
+  })
+  let suggested = ''
+  on('prompt.suggest', (_$, e) => {
+    suggested = e.text
+    return { isShown: true }
+  })
+  const r = await $.session.start({ cwd: '/repo', surface: 'terminal', isInteractive: true })
+  expect(r.cwd).toBe('/repo')
+  await clock.settle() // the refresh is never awaited on the start path
+  expect(argv).toEqual(['8sync', 'ccc', 'hint', '--json'])
+  expect(cwd).toBe('/repo')
+  expect(env?.CLAUDE_CODE_SESSION_ID).toBe('sess-1')
+  expect(suggested).toBe('tiếp tục loop x (iter 1/2)')
+  suggested = ''
+  await clock.advance(20_000) // idle poll
+  expect(suggested).toBe('tiếp tục loop x (iter 1/2)')
+})
+
+test('a subagent turn does not pause or trigger the refresh; the main turn does', async ($, on) => {
+  const clock = mock.clock(on)
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  let runs = 0
+  on('process.run', () => {
+    runs += 1
+    return ok('{"suggest":null,"band":["⎇ main"]}')
+  })
+  on('turn.start', (_$, e) => ({ turnId: e.turnId }))
+  on('turn.complete', () => ({ text: 'done' }))
+  await $.session.start({ cwd: '/repo', surface: 'terminal', isInteractive: true })
+  await clock.settle()
+  expect(runs).toBe(1)
+  await $.turn.start({ text: 'go', turnId: 't1' })
+  await clock.advance(20_000) // the poll is skipped while the main turn runs
+  await $.turn.complete({ turnId: 't2', agentId: 'a1', answer: 'sub', reason: 'answer' })
+  await clock.settle()
+  expect(runs).toBe(1)
+  const r = await $.turn.complete({ turnId: 't1', answer: 'main', reason: 'answer' })
+  expect(r.text).toBe('done')
+  await clock.settle()
+  expect(runs).toBe(2)
+})
+
+test('a failing 8sync is silent: no suggestion, session still starts', async ($, on) => {
+  mock.clock(on)
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  on('process.run', () => ({ value: { exitCode: 127, stdout: '', stderr: 'not found', isStdoutTruncated: false, isStderrTruncated: false } }))
+  let suggested = 0
+  on('prompt.suggest', () => {
+    suggested += 1
+    return { isShown: true }
+  })
+  const r = await $.session.start({ cwd: '/repo', surface: 'terminal', isInteractive: true })
+  expect(r.cwd).toBe('/repo')
+  expect(suggested).toBe(0)
+})
+
+test('headless session does not poll', async ($, on) => {
+  mock.clock(on)
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  let runs = 0
+  on('process.run', () => {
+    runs += 1
+    return ok('{"suggest":null,"band":[]}')
+  })
+  await $.session.start({ cwd: '/repo', surface: null, isInteractive: false })
+  expect(runs).toBe(0)
+})
+
+test('AbovePrompt draws the band and Ẩn hides it', async ($, on) => {
+  mock.clock(on)
+  on('session.start', (_$, e) => ({ cwd: e.cwd }))
+  on('process.run', () => ok('{"suggest":null,"band":["loop x 1/2","⎇ feat ↑2 ✎"]}'))
+  // The engine's own band when the plugin yields (hidden): an empty line.
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return Text({ children: 'engine-band' })
+  })
+  await $.session.start({ cwd: '/repo', surface: 'terminal', isInteractive: true })
+  const mounts = []
+  for (const surface of ['terminal', 'desktop'] as const) {
+    const m = await $.ui.mount({
+      plugin: '8sync-hints',
+      surface,
+      component: 'AbovePrompt',
+      props: { hasSurvey: false, isWorking: false, maxRows: 8, bodyColumns: 100, scroll: { offset: 0, bodyRows: 8 }, view: {} },
+    })
+    expect(JSON.stringify(await m.drawn())).toContain('loop x 1/2')
+    mounts.push(m)
+  }
+  // Ẩn is session state: pressed on one surface, the band is gone on every surface.
+  await mounts[0].press({ key: 'hide' })
+  for (const m of mounts) {
+    expect(JSON.stringify(await m.drawn())).not.toContain('loop x 1/2')
+  }
+})
diff --git a/assets/claude/skills/8sync-hints/hooks/hint.ts b/assets/claude/skills/8sync-hints/hooks/hint.ts
new file mode 100644
index 00000000..aa995b23
--- /dev/null
+++ b/assets/claude/skills/8sync-hints/hooks/hint.ts
@@ -0,0 +1,66 @@
+// Pure helpers of the 8sync-hints mod: parse what `8sync ccc hint --json` prints and decide
+// what to ask it for. No `$`, no I/O — so `hint.test.ts` can check them directly.
+
+export type Hint = { suggest: string | null; band: string[] }
+export type Row = { text: string; label?: string; description?: string }
+
+const MAX_BAND_LINES = 2
+const MAX_ROWS = 8
+
+/** `{suggest, band}` from `8sync ccc hint --json`; null when the output is not that. */
+export function parseHint(stdout: string | null | undefined): Hint | null {
+  const v = parseJson(stdout)
+  if (!v) return null
+  const suggest = typeof v.suggest === 'string' && v.suggest.trim() !== '' ? v.suggest.trim() : null
+  const band = Array.isArray(v.band)
+    ? v.band.filter((l): l is string => typeof l === 'string' && l.trim() !== '').slice(0, MAX_BAND_LINES)
+    : []
+  return { suggest, band }
+}
+
+/** Typeahead rows from `8sync ccc hint --complete <arg> --json`; [] when none or malformed. */
+export function parseComplete(stdout: string | null | undefined): Row[] {
+  const v = parseJson(stdout)
+  if (!v || !Array.isArray(v.complete)) return []
+  const rows: Row[] = []
+  for (const r of v.complete) {
+    if (!r || typeof r !== 'object') continue
+    const o = r as Record<string, unknown>
+    if (typeof o.text !== 'string' || o.text === '') continue
+    const row: Row = { text: o.text }
+    if (typeof o.label === 'string' && o.label !== '') row.label = o.label
+    if (typeof o.description === 'string' && o.description !== '') row.description = o.description
+    rows.push(row)
+    if (rows.length >= MAX_ROWS) break
+  }
+  return rows
+}
+
+/**
+ * What to pass to `--complete` for the prompt box as it stands, or null when the token is not
+ * ours. `/…` tokens: the token itself when it looks like a skill name (not a path like
+ * `/home/x`) and does not stand at the very start of the box (there the engine's own slash
+ * menu already lists every skill). A line that starts with `8sync` or `ccc`: the line up to the
+ * cursor (the Rust side answers with the replacement for the last word).
+ */
+export function completeArg(text: string, cursor: number, token: string, start = -1): string | null {
+  if (token.startsWith('/')) {
+    return start !== 0 && /^\/[\w:.-]*$/.test(token) ? token : null
+  }
+  const head = text.slice(0, cursor)
+  const line = head.slice(head.lastIndexOf('\n') + 1).trimStart()
+  if (/^(8sync|ccc)(\s|$)/.test(line)) return line
+  return null
+}
+
+function parseJson(stdout: string | null | undefined): Record<string, unknown> | null {
+  if (typeof stdout !== 'string') return null
+  const s = stdout.trim()
+  if (s === '' || s[0] !== '{') return null
+  try {
+    const v: unknown = JSON.parse(s)
+    return v !== null && typeof v === 'object' && !Array.isArray(v) ? (v as Record<string, unknown>) : null
+  } catch {
+    return null
+  }
+}
diff --git a/assets/claude/skills/8sync-hints/hooks/hooks.json b/assets/claude/skills/8sync-hints/hooks/hooks.json
new file mode 100644
index 00000000..5a63f649
--- /dev/null
+++ b/assets/claude/skills/8sync-hints/hooks/hooks.json
@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }
diff --git a/assets/claude/skills/8sync-hints/hooks/register.tsx b/assets/claude/skills/8sync-hints/hooks/register.tsx
new file mode 100644
index 00000000..140c15ba
--- /dev/null
+++ b/assets/claude/skills/8sync-hints/hooks/register.tsx
@@ -0,0 +1,115 @@
+// 8sync-hints: a thin drawing layer over `8sync ccc hint` (Rust, local-only, < 50 ms).
+//   · session.start / turn.complete / every 20 s while idle → `8sync ccc hint --json`
+//     → ghost text in the empty prompt box (Tab takes it) + the band above the prompt.
+//   · prompt.autocomplete for `/skill`, `8sync …`, `ccc …` tokens → `--complete`.
+// Any failure (no `8sync` on PATH, bad JSON, timeout) is silent, and `8sync` is never awaited
+// on the path of a prompt or a turn: the refresh runs beside them, so the box never waits.
+import { atom, read, update } from 'claude-code'
+import type { Engine, Register } from 'claude-code'
+
+import { completeArg, parseComplete, parseHint } from './hint'
+
+const band = atom({ plugin: '8sync-hints', key: 'band' } as const, [] as string[])
+const isHidden = atom({ plugin: '8sync-hints', key: 'isHidden' } as const, false)
+
+const POLL_MS = 20_000
+const RUN_TIMEOUT_MS = 1_500
+const CACHE_MS = 10_000
+
+// Module state (reset on every load/reload; `$.state` atoms above survive).
+const st = { cwd: '', sessionId: '', isWorking: false, inflight: false }
+const cache = new Map<string, { at: number; rows: ReturnType<typeof parseComplete> }>()
+
+async function hint($: Engine, args: readonly string[]): Promise<string | null> {
+  try {
+    const r = await $.process.run(['8sync', 'ccc', 'hint', ...args, '--json'], {
+      cwd: st.cwd === '' ? undefined : st.cwd,
+      // So `hint` can find this session's own urgent flag in the ccc registry.
+      env: st.sessionId === '' ? undefined : { CLAUDE_CODE_SESSION_ID: st.sessionId },
+      timeoutMs: RUN_TIMEOUT_MS,
+    })
+    return r.exitCode === 0 ? r.stdout : null
+  } catch {
+    return null
+  }
+}
+
+async function refresh($: Engine): Promise<void> {
+  if (st.inflight || st.isWorking) return
+  st.inflight = true
+  try {
+    const h = parseHint(await hint($, []))
+    if (h === null) return
+    await update($, band, () => h.band)
+    if (h.suggest !== null) {
+      // The engine answers { isShown: false } by itself while the box holds text or a turn runs.
+      await $.prompt.suggest({ text: h.suggest })
+    }
+  } catch {
+    // silent: hints are best-effort
+  } finally {
+    st.inflight = false
+  }
+}
+
+export const register: Register = on => {
+  on('session.start', async ($, e, next) => {
+    st.cwd = e.cwd
+    try {
+      st.sessionId = await $.session.id()
+    } catch {
+      st.sessionId = ''
+    }
+    if (e.isInteractive) {
+      void refresh($)
+      $.clock.every(POLL_MS, () => {
+        void refresh($)
+      })
+    }
+    return next(e)
+  })
+
+  // Main loop only (`agentId` names a subagent's turn): no polling while the model works.
+  on('turn.start', ($, e, next) => {
+    if (e.agentId === undefined) st.isWorking = true
+    return next(e)
+  })
+
+  on('turn.complete', async ($, e, next) => {
+    const r = await next(e)
+    if (e.agentId === undefined) {
+      st.isWorking = false
+      void refresh($)
+    }
+    return r
+  })
+
+  on('prompt.autocomplete', async ($, e, next) => {
+    const arg = completeArg(e.text, e.cursor, e.token, e.start)
+    if (arg === null) return next(e)
+    const below = await next(e)
+    const now = await $.clock.now()
+    const hit = cache.get(arg)
+    let rows = hit !== undefined && now - hit.at < CACHE_MS ? hit.rows : undefined
+    if (rows === undefined) {
+      rows = parseComplete(await hint($, ['--complete', arg]))
+      cache.set(arg, { at: now, rows })
+      if (cache.size > 64) cache.clear()
+    }
+    return { suggestions: [...below.suggestions, ...rows] }
+  })
+
+  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
+    const lines = await read($, band)
+    if (e.props.hasSurvey || lines.length === 0 || (await read($, isHidden))) {
+      return next(e)
+    }
+    const { Box, Button, Text } = $.ui.resolve(e)
+    return (
+      <Box>
+        <Text dimColor>{lines.join('  ·  ')} </Text>
+        <Button key="hide" label="Ẩn" onPress={() => update($, isHidden, () => true)} />
+      </Box>
+    )
+  })
+}
diff --git a/assets/claude/skills/8sync-hints/types/index.d.ts b/assets/claude/skills/8sync-hints/types/index.d.ts
new file mode 100644
index 00000000..f35ced63
--- /dev/null
+++ b/assets/claude/skills/8sync-hints/types/index.d.ts
@@ -0,0 +1,5 @@
+declare module 'claude-code' {
+  interface PluginState {
+    '8sync-hints': { band: string[]; isHidden: boolean }
+  }
+}
diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml
index 072e6221..fd1fb270 100644
--- a/crates/cli/Cargo.toml
+++ b/crates/cli/Cargo.toml
@@ -26,6 +26,8 @@ web = ["dep:axum", "dep:tokio", "dep:tower-http", "dep:scraper"]
 
 [dependencies]
 clap = { version = "4.5", features = ["derive", "wrap_help"] }
+# `8sync completions <shell>`: tab-completion scripts generated from the same clap tree.
+clap_complete = "4.5"
 anyhow = "1.0"
 ccc-core = { path = "../ccc-core" }
 owo-colors = "4.1"
diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs
index dfc0ac18..21b0d7ff 100644
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -168,6 +168,9 @@ enum Cmd {
 
     /// Học từ repo mới nổi trên GitHub (search API chính thức): 8sync learn trending
     Learn(verbs::learn::Args),
+
+    /// Shell tab-completion script for `8sync`: 8sync completions <bash|zsh|fish|powershell|elvish>
+    Completions(verbs::completions::Args),
 }
 
 fn main() -> Result<()> {
@@ -229,6 +232,7 @@ fn main() -> Result<()> {
         Some(Cmd::Hq(a))      => verbs::hq::run(a),
         Some(Cmd::Forge(a))   => verbs::forge::run(a),
         Some(Cmd::Ccc(a))     => verbs::ccc::run(a),
+        Some(Cmd::Completions(a)) => verbs::completions::run(a),
         Some(Cmd::Watchdog(a)) => verbs::watchdog::run(a),
         Some(Cmd::Learn(a)) => verbs::learn::run(a),
         Some(Cmd::Ls(a))      => verbs::session_cmds::run_ls(a),
@@ -237,6 +241,13 @@ fn main() -> Result<()> {
     }
 }
 
+/// The full `8sync` command tree as the binary parses it (brand-rewritten): shared by shell
+/// completions and the `ccc hint` typeahead so both list exactly what `main` accepts.
+pub(crate) fn command() -> clap::Command {
+    use clap::CommandFactory;
+    rebrand_cmd(Cli::command())
+}
+
 /// Rebrand a clap `Command` tree in place: run `brand::render` over `about`,
 /// `long_about`, and `after_help` for the root and every (nested) subcommand.
 /// Identity fast-path on the default build so help output is byte-for-byte
diff --git a/crates/cli/src/verbs/ccc.rs b/crates/cli/src/verbs/ccc.rs
index 43d45f28..92224139 100644
--- a/crates/cli/src/verbs/ccc.rs
+++ b/crates/cli/src/verbs/ccc.rs
@@ -29,6 +29,7 @@ mod gate;
 mod grant;
 mod guard;
 mod help;
+mod hint;
 mod idle;
 mod looper;
 mod output_budget;
@@ -173,6 +174,13 @@ pub fn run(a: Args) -> Result<()> {
         "status" => status(&env, &root),
         "policy" => policy(rest),
         "loop" => looper::run(rest, &std::env::current_dir().context("no cwd")?),
+        "hint" => {
+            let cwd = std::env::current_dir().context("no cwd")?;
+            let id = std::env::var("CLAUDE_CODE_SESSION_ID").ok();
+            let reg = sessions(&env, &root).load();
+            let cd = claude_dir(&env);
+            hint::run(rest, &hint::Ctx { cwd: &cwd, home: &env.home, claude_dir: &cd, registry: Some(&reg), session_id: id.as_deref(), now: view_now(), git: true })
+        }
         "ls" | "list" => {
             print_sessions(&env, &root, rest.iter().any(|a| a == "--json"))
         }
@@ -538,7 +546,7 @@ fn install_claude() -> Result<()> {
 
 /// Kit files: (asset path, path under Claude Code's config dir). The shared
 /// skills come from omp's bundled tree, so both harnesses read one source.
-const KIT_FILES: [(&str, &str); 29] = [
+const KIT_FILES: [(&str, &str); 34] = [
     ("claude/agents/explore.md", "agents/explore.md"),
     ("claude/agents/task.md", "agents/task.md"),
     ("claude/agents/quick-task.md", "agents/quick-task.md"),
@@ -569,6 +577,13 @@ const KIT_FILES: [(&str, &str); 29] = [
     ("skills/aup-audit/8sync-anthropic-rules.md", "skills/aup-audit/8sync-anthropic-rules.md"),
     ("skills/deep-research/SKILL.md", "skills/deep-research/SKILL.md"),
     ("skills/deep-research/references/binary-weight-audit.md", "skills/deep-research/references/binary-weight-audit.md"),
+    // Mod `8sync-hints` (Claude Code function hooks): a plugin folder under ~/.claude/skills is
+    // auto-loaded, so this is all it takes for ghost text + typeahead + the band above the prompt.
+    ("claude/skills/8sync-hints/.claude-plugin/plugin.json", "skills/8sync-hints/.claude-plugin/plugin.json"),
+    ("claude/skills/8sync-hints/hooks/hooks.json", "skills/8sync-hints/hooks/hooks.json"),
+    ("claude/skills/8sync-hints/hooks/register.tsx", "skills/8sync-hints/hooks/register.tsx"),
+    ("claude/skills/8sync-hints/hooks/hint.ts", "skills/8sync-hints/hooks/hint.ts"),
+    ("claude/skills/8sync-hints/types/index.d.ts", "skills/8sync-hints/types/index.d.ts"),
 ];
 
 /// Files an earlier kit installed and this one dropped: deleted while they are
@@ -2344,4 +2359,29 @@ mod tests {
         assert!(!home.join(".claude.json").exists(), "offline kit must not touch MCP config");
         let _ = std::fs::remove_dir_all(&tmp);
     }
+
+    /// The `8sync-hints` mod ships in the kit: five files under `skills/8sync-hints`, written
+    /// byte-for-byte from the repo assets (the cbm gate leaves non-markdown alone).
+    #[test]
+    fn kit_installs_the_hints_mod() {
+        let mod_files: Vec<&str> = KIT_FILES.iter().map(|(_, r)| *r).filter(|r| r.starts_with("skills/8sync-hints/")).collect();
+        assert_eq!(mod_files.len(), 5, "{mod_files:?}");
+        for f in ["skills/8sync-hints/.claude-plugin/plugin.json", "skills/8sync-hints/hooks/hooks.json", "skills/8sync-hints/hooks/register.tsx", "skills/8sync-hints/hooks/hint.ts", "skills/8sync-hints/types/index.d.ts"] {
+            assert!(mod_files.contains(&f), "{f}");
+        }
+        let tmp = std::env::temp_dir().join(format!("8sync-hints-kit-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&tmp);
+        let home = tmp.join("home");
+        std::fs::create_dir_all(&home).unwrap();
+        let env = Env { home: home.clone(), xdg_config: home.join(".config"), os_id: String::new(), os_id_like: String::new() };
+        let dir = tmp.join("claude");
+        install_kit_at(&env, &dir, false, true).unwrap();
+        let reg = std::fs::read_to_string(dir.join("skills/8sync-hints/hooks/register.tsx")).unwrap();
+        assert_eq!(reg, assets::read("claude/skills/8sync-hints/hooks/register.tsx").unwrap());
+        assert!(reg.contains("'8sync', 'ccc', 'hint'"), "the mod calls the Rust side");
+        let manifest: Value = serde_json::from_str(&std::fs::read_to_string(dir.join("skills/8sync-hints/.claude-plugin/plugin.json")).unwrap()).unwrap();
+        assert_eq!(manifest["name"], "8sync-hints");
+        assert_eq!(manifest["types"], "./types/index.d.ts");
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
 }
diff --git a/crates/cli/src/verbs/ccc/help.rs b/crates/cli/src/verbs/ccc/help.rs
index 8cc7c390..74376cb9 100644
--- a/crates/cli/src/verbs/ccc/help.rs
+++ b/crates/cli/src/verbs/ccc/help.rs
@@ -4,11 +4,11 @@
 /// Every top-level verb the dispatcher in `ccc::run` routes (plus `help` itself).
 #[cfg(test)]
 pub(super) const VERBS: &[&str] =
-    &["help", "hook", "statusline", "kit", "login-kind", "show", "report", "status", "policy", "loop", "ls", "list", "urgent", "goal", "standup", "rm", "new", "compact", "secret", "idle", "delegate"];
+    &["help", "hook", "statusline", "kit", "login-kind", "show", "report", "status", "policy", "loop", "hint", "ls", "list", "urgent", "goal", "standup", "rm", "new", "compact", "secret", "idle", "delegate"];
 
 /// Words that look like verbs: never a session name, never a headless claude launch.
 /// Includes hook sub-verbs people type without `hook`.
-pub(super) const RESERVED: &[&str] = &["help", "compact", "statusline", "login-kind", "show", "report", "loop", "kit", "guard", "hook", "ship-grant", "secret", "idle", "delegate"];
+pub(super) const RESERVED: &[&str] = &["help", "compact", "statusline", "login-kind", "show", "report", "loop", "hint", "kit", "guard", "hook", "ship-grant", "secret", "idle", "delegate"];
 
 pub(super) const TEXT: &str = "\
 8sync ccc — Claude Code + kit của 8 Sync. Mọi lệnh (chạy `8sync ccc <verb>`):
@@ -54,6 +54,8 @@ XEM
   8sync ccc . show <tên> [--json]   tóm tắt một session
   8sync ccc . report [--json]       token, cost (số Claude Code báo statusline), thời gian, +/- dòng, task xong, cost/task, loop
   8sync hq ui                       dashboard HQ trong trình duyệt
+  8sync ccc hint [--complete <token>] [--json]   gợi ý prompt kế (ghost text), band trên prompt, typeahead /skill · 8sync · ccc — mod 8sync-hints gọi
+  8sync completions <bash|zsh|fish|powershell|elvish>   script tab-completion cho lệnh 8sync (nguồn vào shell rc)
 
 AN TOÀN
   8sync ccc hook <verify|verify-stop|guard|watchdog|session-start|stop-failure|resume-note|ship-grant|idle|task-done|delegate|wake>
diff --git a/crates/cli/src/verbs/ccc/hint.rs b/crates/cli/src/verbs/ccc/hint.rs
new file mode 100644
index 00000000..eae796cf
--- /dev/null
+++ b/crates/cli/src/verbs/ccc/hint.rs
@@ -0,0 +1,751 @@
+//! `8sync ccc hint [--complete <token>] [--json]`: what the `8sync-hints` mod draws inside
+//! Claude Code — a ghost-text suggestion for the next prompt, a ≤2-line band above the prompt,
+//! and typeahead rows for `/skill`, `8sync …`, `ccc …` tokens. Idea ported from omp's predictive
+//! composer (n-gram over the owner's own prompt history); the code is ours. Everything is read
+//! from local files only (no network, no `gh`) plus one `git status` call with a [`GIT_BUDGET`]
+//! budget; everything but git stays under 50 ms. The mod runs it beside the prompt, never in
+//! its way, so a slow git (a Windows spawn takes ~100 ms) only delays the band.
+
+use std::collections::HashMap;
+use std::io::{Read, Seek, SeekFrom};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::Duration;
+
+use anyhow::Result;
+use serde_json::{json, Value};
+
+use ccc_core::registry::Registry;
+
+/// Max rows for a typeahead answer.
+const MAX_ROWS: usize = 8;
+/// Longest ghost-text suggestion (one terminal line).
+const MAX_SUGGEST: usize = 120;
+/// SKILL.md bytes read per skill (frontmatter only).
+const SKILL_HEAD: usize = 2048;
+/// Tail of `history.jsonl` read per call (the file grows for ever; the bigram needs recent use).
+const HISTORY_TAIL: u64 = 512 * 1024;
+/// `git status` budget. 50 ms was too tight for a Windows spawn (CI run 38837734481: no branch).
+const GIT_BUDGET: Duration = Duration::from_millis(300);
+/// Watchdog alert is "fresh" for this long (same as the statusline).
+const ALERT_FRESH_S: u64 = 600;
+
+/// ccc verbs with a one-line description — the `8sync ccc <verb>` typeahead table.
+pub(super) const CCC_VERBS: &[(&str, &str)] = &[
+    (".", "session theo tên trong repo này: 8sync ccc . <tên>"),
+    ("help", "mọi verb của ccc trên một màn hình"),
+    ("kit", "cài/làm mới kit (hook, skill, mod) vào ~/.claude"),
+    ("status", "guard, gate, mod có đang bật không"),
+    ("hint", "gợi ý prompt kế + band + typeahead (mod 8sync-hints gọi)"),
+    ("loop", "vòng lặp /ship-loop: init · tick · status · done · ev"),
+    ("standup", "bảng sprint: role nào rảnh, việc trùng file"),
+    ("ls", "session của repo, mới nhất lên đầu"),
+    ("report", "token, cost, thời gian, loop"),
+    ("show", "tóm tắt một session"),
+    ("urgent", "đặt mức cần owner chú ý: high|med|low|clear"),
+    ("goal", "mục tiêu + file phòng này đang giữ"),
+    ("compact", "nén transcript theo cách của kit"),
+    ("secret", "đưa secret vào Encore/Vercel/GitHub qua stdin"),
+    ("idle", "gate TaskCompleted khi code chưa test"),
+    ("delegate", "critic trả lời thay owner câu hỏi kỹ thuật"),
+    ("policy", "managed-settings / deny rule của máy"),
+    ("login-kind", "subscription hay API key"),
+    ("hook", "hook do kit đăng ký (không gõ tay)"),
+    ("statusline", "dòng trạng thái (kit gọi)"),
+];
+
+/// Everything `hint` reads; built once per call so tests can point it at a fixture.
+pub(super) struct Ctx<'a> {
+    pub cwd: &'a Path,
+    pub home: &'a Path,
+    /// `$CLAUDE_CONFIG_DIR` or `~/.claude`: skills + history.jsonl live here.
+    pub claude_dir: &'a Path,
+    pub registry: Option<&'a Registry>,
+    pub session_id: Option<&'a str>,
+    pub now: u64,
+    /// Run `git status` (false in unit tests that must not spawn).
+    pub git: bool,
+}
+
+/// One typeahead row (what `prompt.autocomplete` expects).
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub(super) struct Row {
+    pub text: String,
+    pub label: String,
+    pub description: String,
+}
+
+impl Row {
+    fn json(&self) -> Value {
+        json!({ "text": self.text, "label": self.label, "description": self.description })
+    }
+}
+
+/// An active `/ship-loop`: first slug in `su-code/ship/ACTIVE` whose loop.json is not stopped.
+#[derive(Debug, PartialEq, Eq)]
+pub(super) struct Loop {
+    pub slug: String,
+    pub iter: u64,
+    pub max_iter: u64,
+}
+
+/// What `git status --porcelain=v2 --branch` says, reduced to what the hints need.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub(super) struct Git {
+    pub branch: Option<String>,
+    pub ahead: u64,
+    pub dirty: bool,
+}
+
+/// The repo state both `suggest` and `band` read, gathered once per call.
+#[derive(Debug, Default)]
+pub(super) struct Facts {
+    pub active: Option<Loop>,
+    /// `level[: note]` of this session's own urgent flag.
+    pub urgency: Option<String>,
+    pub git: Git,
+    pub alert: Option<String>,
+}
+
+pub(super) fn run(rest: &[String], cx: &Ctx) -> Result<()> {
+    let json = rest.iter().any(|a| a == "--json");
+    let token = rest.iter().position(|a| a == "--complete").and_then(|i| rest.get(i + 1));
+    let out = match token {
+        Some(tok) => render_complete(&complete(tok, cx)),
+        None => render_hint(cx),
+    };
+    if json {
+        println!("{out}");
+    } else if token.is_some() {
+        for r in out["complete"].as_array().into_iter().flatten() {
+            println!("{}\t{}\t{}", r["text"].as_str().unwrap_or(""), r["label"].as_str().unwrap_or(""), r["description"].as_str().unwrap_or(""));
+        }
+    } else {
+        if let Some(s) = out["suggest"].as_str() {
+            println!("→ {s}");
+        }
+        for l in out["band"].as_array().into_iter().flatten().filter_map(Value::as_str) {
+            println!("{l}");
+        }
+    }
+    Ok(())
+}
+
+/// `{"suggest": string|null, "band": [string]}` — the contract `hint.ts` parses.
+pub(super) fn render_hint(cx: &Ctx) -> Value {
+    let f = gather(cx);
+    json!({ "suggest": suggest(cx, &f), "band": band(&f) })
+}
+
+/// `{"complete": [{text,label,description}]}`.
+pub(super) fn render_complete(rows: &[Row]) -> Value {
+    json!({ "complete": rows.iter().map(Row::json).collect::<Vec<_>>() })
+}
+
+pub(super) fn gather(cx: &Ctx) -> Facts {
+    Facts {
+        active: active_loop(cx.cwd),
+        urgency: own_urgency(cx),
+        git: if cx.git { git_status(cx.cwd) } else { Git::default() },
+        alert: fresh_alert(cx.home, cx.now),
+    }
+}
+
+/// The next prompt the owner most likely wants (ghost text). Priority: open loop, own urgent
+/// flag, bigram from the owner's own history, then git state.
+pub(super) fn suggest(cx: &Ctx, f: &Facts) -> Option<String> {
+    if let Some(l) = &f.active {
+        return Some(format!("tiếp tục loop {} (iter {}/{})", l.slug, l.iter, l.max_iter));
+    }
+    if let Some(u) = &f.urgency {
+        return Some(format!("đã xem urgent {u}; làm tiếp rồi 8sync ccc . urgent clear"));
+    }
+    if let Some(p) = predict_next(&history_tail(&cx.claude_dir.join("history.jsonl")), &cx.cwd.to_string_lossy()) {
+        return Some(p);
+    }
+    suggest_from_git(&f.git)
+}
+
+fn suggest_from_git(g: &Git) -> Option<String> {
+    let b = g.branch.as_deref()?;
+    if g.dirty {
+        return Some("/sec rồi commit theo conventional commits".into());
+    }
+    if g.ahead > 0 {
+        return Some(format!("push nhánh {b} rồi mở PR"));
+    }
+    None
+}
+
+/// ≤ 2 short Vietnamese lines for the band above the prompt. Line 1: loop · git. Line 2:
+/// urgent · watchdog alert. Empty parts are dropped; an empty vec means "draw nothing".
+pub(super) fn band(f: &Facts) -> Vec<String> {
+    let mut l1 = Vec::new();
+    if let Some(l) = &f.active {
+        l1.push(format!("loop {} {}/{}", l.slug, l.iter, l.max_iter));
+    }
+    if let Some(b) = &f.git.branch {
+        let mut s = format!("⎇ {b}");
+        if f.git.ahead > 0 {
+            s.push_str(&format!(" ↑{}", f.git.ahead));
+        }
+        if f.git.dirty {
+            s.push_str(" ✎");
+        }
+        l1.push(s);
+    }
+    let mut l2 = Vec::new();
+    if let Some(u) = &f.urgency {
+        l2.push(format!("urgent {u}"));
+    }
+    if let Some(a) = &f.alert {
+        l2.push(format!("watchdog: {a}"));
+    }
+    [l1, l2].into_iter().filter(|l| !l.is_empty()).map(|l| l.join(" · ")).collect()
+}
+
+/// Typeahead rows for the token under the cursor: `/…` → installed skills, `8sync …` → top-level
+/// 8sync commands, `8sync ccc …` / `ccc …` → ccc verbs. Prefix matches first, then subsequence.
+/// A row whose label is exactly the query is dropped (the engine asks again once a row is taken).
+pub(super) fn complete(token: &str, cx: &Ctx) -> Vec<Row> {
+    let token = token.trim_start();
+    if let Some(q) = token.strip_prefix('/') {
+        let q = q.split_whitespace().next().unwrap_or("");
+        if !q.chars().all(|c| c.is_alphanumeric() || matches!(c, '-' | '_' | ':' | '.')) {
+            return Vec::new(); // a path like /home/…, not a skill name
+        }
+        let mut rows: Vec<Row> = skills(cx).into_iter().map(|(n, d)| Row { text: format!("/{n}"), label: n, description: d }).collect();
+        rows.sort_by(|a, b| a.label.cmp(&b.label));
+        return rank(q, rows);
+    }
+    let words: Vec<&str> = token.split_whitespace().collect();
+    let trailing = token.ends_with(char::is_whitespace);
+    // `text` replaces the word under the cursor (what `prompt.autocomplete` writes): a partial
+    // last word gets the match alone; a complete keyword with no space after it ("8sync", "ccc")
+    // is the token itself, so the row re-writes it followed by the match.
+    match words.as_slice() {
+        ["ccc", rest @ ..] | ["8sync", "ccc", rest @ ..] => {
+            let q = if trailing { "" } else { rest.first().copied().unwrap_or("") };
+            if rest.len() > usize::from(!trailing) {
+                return Vec::new();
+            }
+            let lead = if !trailing && rest.is_empty() { "ccc " } else { "" };
+            let rows = CCC_VERBS.iter().map(|(v, d)| Row { text: format!("{lead}{v}"), label: v.to_string(), description: d.to_string() }).collect();
+            rank(q, rows)
+        }
+        ["8sync", rest @ ..] => {
+            let q = if trailing { "" } else { rest.first().copied().unwrap_or("") };
+            if rest.len() > usize::from(!trailing) {
+                return Vec::new();
+            }
+            let lead = if !trailing && rest.is_empty() { "8sync " } else { "" };
+            let rows = top_commands().into_iter().map(|(n, d)| Row { text: format!("{lead}{n}"), label: n, description: d }).collect();
+            rank(q, rows)
+        }
+        _ => Vec::new(),
+    }
+}
+
+/// `8sync` top-level subcommands with their one-line about, from the clap tree (brand-rewritten).
+fn top_commands() -> Vec<(String, String)> {
+    crate::command()
+        .get_subcommands()
+        .filter(|c| !c.is_hide_set())
+        .map(|c| (c.get_name().to_string(), c.get_about().map(|a| a.to_string()).unwrap_or_default()))
+        .collect()
+}
+
+/// Prefix matches (in input order) then subsequence matches, capped at [`MAX_ROWS`]; never a
+/// row that only repeats the query.
+pub(super) fn rank(q: &str, rows: Vec<Row>) -> Vec<Row> {
+    let q = q.to_lowercase();
+    let rows: Vec<Row> = rows.into_iter().filter(|r| r.label.to_lowercase() != q).collect();
+    let (mut pre, rest): (Vec<Row>, Vec<Row>) = rows.into_iter().partition(|r| r.label.to_lowercase().starts_with(&q));
+    pre.extend(rest.into_iter().filter(|r| !q.is_empty() && is_subsequence(&q, &r.label.to_lowercase())));
+    pre.truncate(MAX_ROWS);
+    pre
+}
+
+fn is_subsequence(q: &str, s: &str) -> bool {
+    let mut it = s.chars();
+    q.chars().all(|c| it.any(|x| x == c))
+}
+
+/// Installed skills: `<claude_dir>/skills/*/SKILL.md` (symlinks followed) then the repo's own
+/// `.claude/skills`. Repo entries override user ones with the same name.
+fn skills(cx: &Ctx) -> Vec<(String, String)> {
+    let mut out: HashMap<String, String> = HashMap::new();
+    for dir in [cx.claude_dir.join("skills"), cx.cwd.join(".claude/skills")] {
+        let Ok(rd) = std::fs::read_dir(&dir) else { continue };
+        let mut names: Vec<PathBuf> = rd.flatten().map(|e| e.path()).collect();
+        names.sort();
+        for p in names {
+            let Some((n, d)) = skill_meta(&p.join("SKILL.md"), &p) else { continue };
+            out.insert(n, d);
+        }
+    }
+    out.into_iter().collect()
+}
+
+/// `name` + `description` from a SKILL.md frontmatter (first [`SKILL_HEAD`] bytes); the folder
+/// name when the frontmatter has no `name`.
+fn skill_meta(skill_md: &Path, dir: &Path) -> Option<(String, String)> {
+    let mut f = std::fs::File::open(skill_md).ok()?;
+    let mut buf = vec![0u8; SKILL_HEAD];
+    let n = f.read(&mut buf).ok()?;
+    buf.truncate(n);
+    let head = String::from_utf8_lossy(&buf);
+    let fallback = dir.file_name()?.to_string_lossy().into_owned();
+    Some(parse_frontmatter(&head, &fallback))
+}
+
+/// `(name, description)` from YAML frontmatter: plain or quoted scalars only; a block scalar
+/// (`>` / `|`) is left empty rather than shown as its marker; a BOM before `---` is ignored.
+pub(super) fn parse_frontmatter(head: &str, fallback_name: &str) -> (String, String) {
+    let mut name = None;
+    let mut desc = String::new();
+    let mut lines = head.trim_start_matches('\u{feff}').lines();
+    if lines.next().map(str::trim) == Some("---") {
+        for l in lines {
+            let l = l.trim_end();
+            if l.trim() == "---" {
+                break;
+            }
+            if let Some(v) = l.strip_prefix("name:") {
+                name = Some(scalar(v)).filter(|s| !s.is_empty());
+            } else if let Some(v) = l.strip_prefix("description:") {
+                desc = scalar(v);
+            }
+        }
+    }
+    let mut desc: String = desc.chars().take(MAX_SUGGEST).collect();
+    if let Some(i) = desc.find(". ") {
+        desc.truncate(i + 1);
+    }
+    (name.unwrap_or_else(|| fallback_name.to_string()), desc)
+}
+
+fn scalar(v: &str) -> String {
+    let v = v.trim();
+    if matches!(v.chars().next(), Some('>' | '|')) {
+        return String::new();
+    }
+    v.trim_matches(|c| c == '"' || c == '\'').to_string()
+}
+
+/// `(project, display)` pairs of the last [`HISTORY_TAIL`] bytes of `history.jsonl`, oldest
+/// first; a cut first line and invalid UTF-8 bytes are tolerated.
+fn history_tail(p: &Path) -> Vec<(String, String)> {
+    let Ok(mut f) = std::fs::File::open(p) else { return Vec::new() };
+    let Ok(len) = f.metadata().map(|m| m.len()) else { return Vec::new() };
+    let start = len.saturating_sub(HISTORY_TAIL);
+    if f.seek(SeekFrom::Start(start)).is_err() {
+        return Vec::new();
+    }
+    let mut b = Vec::new();
+    if f.read_to_end(&mut b).is_err() {
+        return Vec::new();
+    }
+    let raw = String::from_utf8_lossy(&b);
+    let mut lines = raw.lines();
+    if start > 0 {
+        lines.next(); // partial line
+    }
+    lines
+        .filter_map(|l| serde_json::from_str::<Value>(l).ok())
+        .filter_map(|o| Some((o["project"].as_str()?.to_string(), o["display"].as_str()?.trim().to_string())))
+        .collect()
+}
+
+/// Bigram prediction: after the prompt the owner typed last in `project`, which prompt did they
+/// type most often the other times? Only this project's history; nothing leaves the machine.
+/// Candidates that carry a secret-looking token or a collapsed paste placeholder are skipped:
+/// a hint must never put a key back on screen, and a placeholder does not expand when taken.
+pub(super) fn predict_next(hist: &[(String, String)], project: &str) -> Option<String> {
+    let mine: Vec<&str> = hist.iter().filter(|(p, d)| p == project && !d.is_empty()).map(|(_, d)| d.as_str()).collect();
+    let last = *mine.last()?;
+    let mut counts: HashMap<&str, usize> = HashMap::new();
+    for w in mine.windows(2) {
+        if w[0] == last && w[1] != last && w[1].chars().count() >= 3 && is_safe_candidate(w[1]) {
+            *counts.entry(w[1]).or_default() += 1;
+        }
+    }
+    let best = counts.into_iter().max_by(|a, b| a.1.cmp(&b.1).then_with(|| b.0.cmp(a.0)))?.0;
+    Some(one_line(best))
+}
+
+fn is_safe_candidate(d: &str) -> bool {
+    !d.contains("[Pasted text") && ccc_core::secret_mask::mask(d) == d
+}
+
+fn one_line(s: &str) -> String {
+    let s: String = s.split_whitespace().collect::<Vec<_>>().join(" ");
+    if s.chars().count() > MAX_SUGGEST {
+        let cut: String = s.chars().take(MAX_SUGGEST - 1).collect();
+        format!("{cut}…")
+    } else {
+        s
+    }
+}
+
+pub(super) fn active_loop(cwd: &Path) -> Option<Loop> {
+    let dir = cwd.ancestors().map(|d| d.join("su-code/ship")).find(|d| d.is_dir())?;
+    let active = std::fs::read_to_string(dir.join("ACTIVE")).ok()?;
+    for slug in active.lines().map(str::trim) {
+        if slug.is_empty() || slug.starts_with('.') || !slug.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.')) {
+            continue;
+        }
+        let Ok(raw) = std::fs::read_to_string(dir.join(slug).join("loop.json")) else { continue };
+        let Ok(v) = serde_json::from_str::<Value>(&raw) else { continue };
+        if !v["stopped"].is_null() {
+            continue;
+        }
+        return Some(Loop { slug: slug.to_string(), iter: v["iter"].as_u64().unwrap_or(0), max_iter: v["max_iter"].as_u64().unwrap_or(0) });
+    }
+    None
+}
+
+fn own_urgency(cx: &Ctx) -> Option<String> {
+    let id = cx.session_id?;
+    let s = cx.registry?.sessions.iter().find(|s| s.conversation_id == id)?;
+    let u = s.urgency.as_ref()?;
+    Some(match &u.note {
+        Some(n) if !n.trim().is_empty() => format!("{}: {}", u.level, one_line(n)),
+        _ => u.level.clone(),
+    })
+}
+
+fn fresh_alert(home: &Path, now: u64) -> Option<String> {
+    let raw = std::fs::read_to_string(home.join(".local/state/8sync/watchdog/alerts.jsonl")).ok()?;
+    let l = raw.lines().rev().find(|l| !l.trim().is_empty())?;
+    let v: Value = serde_json::from_str(l).ok()?;
+    (now.saturating_sub(v["ts"].as_u64()?) <= ALERT_FRESH_S).then(|| v["kind"].as_str().unwrap_or("alert").to_string())
+}
+
+/// One `git status --porcelain=v2 --branch` within [`GIT_BUDGET`]; `Git::default()` when git is
+/// missing, slow, or `cwd` is not a repo. Untracked files count as dirty (a new file still
+/// needs `/sec` and a commit).
+fn git_status(cwd: &Path) -> Git {
+    git_status_within(cwd, GIT_BUDGET)
+}
+
+fn git_status_within(cwd: &Path, budget: Duration) -> Git {
+    let mut c = Command::new("git");
+    c.arg("-C").arg(cwd).args(["status", "--porcelain=v2", "--branch"]).env("GIT_OPTIONAL_LOCKS", "0");
+    super::statusline::run_budget(c, None, budget).map(|s| parse_status(&s)).unwrap_or_default()
+}
+
+pub(super) fn parse_status(out: &str) -> Git {
+    let mut g = Git::default();
+    for l in out.lines() {
+        if let Some(h) = l.strip_prefix("# branch.head ") {
+            g.branch = Some(h.trim().to_string()).filter(|b| b != "(detached)" && !b.is_empty());
+        } else if let Some(ab) = l.strip_prefix("# branch.ab ") {
+            g.ahead = ab.split_whitespace().next().and_then(|a| a.trim_start_matches('+').parse().ok()).unwrap_or(0);
+        } else if l.starts_with(['1', '2', 'u', '?']) {
+            g.dirty = true;
+        }
+    }
+    g
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Instant;
+
+    fn write(p: &Path, s: &str) {
+        std::fs::create_dir_all(p.parent().unwrap()).unwrap();
+        std::fs::write(p, s).unwrap();
+    }
+
+    /// A scratch dir under the OS temp dir, removed on drop (no tempfile dependency).
+    struct Tmp(PathBuf);
+    impl Drop for Tmp {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_dir_all(&self.0);
+        }
+    }
+
+    /// A repo with 40 installed skills and a history whose last prompt was seen twice before,
+    /// followed each time by the same next prompt.
+    fn fixture() -> (Tmp, PathBuf, PathBuf) {
+        static N: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+        let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        let t = Tmp(std::env::temp_dir().join(format!("8sync-hint-{}-{n}", std::process::id())));
+        let _ = std::fs::remove_dir_all(&t.0);
+        let home = t.0.join("home");
+        let cwd = t.0.join("repo");
+        let cd = home.join(".claude");
+        for i in 0..40 {
+            write(&cd.join(format!("skills/sk{i}/SKILL.md")), &format!("---\nname: sk{i}\ndescription: skill số {i}. Chi tiết dài.\n---\n# body\n"));
+        }
+        write(&cd.join("skills/ship/SKILL.md"), "---\nname: ship\ndescription: Chạy trọn quy trình một feature. Dùng khi /ship.\n---\n");
+        write(&cwd.join(".claude/skills/repo-only/SKILL.md"), "---\ndescription: 'skill của repo'\n---\n");
+        let proj = cwd.to_string_lossy().to_string();
+        let mut h = String::new();
+        for _ in 0..2 {
+            h.push_str(&format!("{}\n", json!({"display":"chạy test","project":proj,"timestamp":1})));
+            h.push_str(&format!("{}\n", json!({"display":"commit đi","project":proj,"timestamp":2})));
+        }
+        h.push_str(&format!("{}\n", json!({"display":"chạy test","project":"/other","timestamp":3})));
+        h.push_str(&format!("{}\n", json!({"display":"push","project":"/other","timestamp":4})));
+        h.push_str("not json at all\n");
+        h.push_str(&format!("{}\n", json!({"display":"chạy test","project":proj,"timestamp":5})));
+        write(&cd.join("history.jsonl"), &h);
+        (t, home, cwd)
+    }
+
+    fn ctx<'a>(home: &'a Path, cwd: &'a Path, cd: &'a Path) -> Ctx<'a> {
+        Ctx { cwd, home, claude_dir: cd, registry: None, session_id: None, now: 1_000_000, git: false }
+    }
+
+    fn git(cwd: &Path, args: &[&str]) {
+        let st = Command::new("git")
+            .arg("-C")
+            .arg(cwd)
+            .args(args)
+            .env("GIT_AUTHOR_NAME", "t")
+            .env("GIT_AUTHOR_EMAIL", "t@t")
+            .env("GIT_COMMITTER_NAME", "t")
+            .env("GIT_COMMITTER_EMAIL", "t@t")
+            .output()
+            .unwrap();
+        assert!(st.status.success(), "git {args:?}: {}", String::from_utf8_lossy(&st.stderr));
+    }
+
+    #[test]
+    fn hint_suggest_prefers_open_loop_then_bigram_then_git() {
+        let (_t, home, cwd) = fixture();
+        let cd = home.join(".claude");
+        let cx = ctx(&home, &cwd, &cd);
+        assert_eq!(suggest(&cx, &gather(&cx)).as_deref(), Some("commit đi"), "bigram when no loop");
+        write(&cwd.join("su-code/ship/ACTIVE"), "old\nhints\n");
+        write(&cwd.join("su-code/ship/old/loop.json"), r#"{"iter":3,"max_iter":5,"stopped":"done"}"#);
+        write(&cwd.join("su-code/ship/hints/loop.json"), r#"{"iter":2,"max_iter":12}"#);
+        assert_eq!(suggest(&cx, &gather(&cx)).as_deref(), Some("tiếp tục loop hints (iter 2/12)"));
+        assert_eq!(suggest_from_git(&Git { branch: Some("feat/x".into()), ahead: 2, dirty: false }).as_deref(), Some("push nhánh feat/x rồi mở PR"));
+        assert_eq!(suggest_from_git(&Git { branch: Some("feat/x".into()), ahead: 2, dirty: true }).as_deref(), Some("/sec rồi commit theo conventional commits"));
+        assert_eq!(suggest_from_git(&Git::default()), None);
+    }
+
+    #[test]
+    fn hint_bigram_filters_by_project_and_ignores_self_pairs() {
+        let h = |p: &str, d: &str| (p.to_string(), d.to_string());
+        let hist = vec![h("/a", "x"), h("/a", "x"), h("/b", "x"), h("/b", "zzz"), h("/a", "x")];
+        assert_eq!(predict_next(&hist, "/a"), None, "x→x is not a suggestion; /b's zzz is another project");
+        assert_eq!(predict_next(&hist, "/b"), None, "last /b prompt is zzz, never seen before");
+        assert_eq!(predict_next(&[], "/a"), None);
+    }
+
+    #[test]
+    fn hint_bigram_never_repeats_a_secret_or_a_paste_placeholder() {
+        let h = |d: &str| ("/a".to_string(), d.to_string());
+        let key = format!("dùng key sk-ant-api03-{}", "A".repeat(40));
+        let hist = vec![h("go"), h(&key), h("go"), h(&key), h("go"), h("[Pasted text #1 +12 lines]"), h("go")];
+        assert_eq!(predict_next(&hist, "/a"), None, "the only followers are a key and a placeholder");
+        let hist = vec![h("go"), h(&key), h("go"), h("ok tiếp"), h("go")];
+        assert_eq!(predict_next(&hist, "/a").as_deref(), Some("ok tiếp"), "falls through to the safe candidate");
+    }
+
+    #[test]
+    fn hint_history_tail_skips_a_cut_first_line() {
+        let (_t, home, _cwd) = fixture();
+        let p = home.join("big.jsonl");
+        let mut s = String::new();
+        let line = format!("{}\n", json!({"display":"filler prompt that is long enough","project":"/x","timestamp":1}));
+        while s.len() < HISTORY_TAIL as usize + 4096 {
+            s.push_str(&line);
+        }
+        s.push_str(&format!("{}\n", json!({"display":"last","project":"/x","timestamp":2})));
+        write(&p, &s);
+        let h = history_tail(&p);
+        assert!(h.len() > 1000 && h.len() < 7000, "{}", h.len());
+        assert_eq!(h.last().unwrap().1, "last");
+        assert!(h.iter().all(|(_, d)| d == "last" || d == "filler prompt that is long enough"), "no cut line parsed");
+        assert!(history_tail(&home.join("missing.jsonl")).is_empty());
+        // QA (2026-10-16): one invalid-UTF-8 line must not throw the whole history away.
+        let p = home.join("bad.jsonl");
+        let mut b = format!("{}\n", json!({"display":"go","project":"/x","timestamp":1})).into_bytes();
+        b.extend_from_slice(b"\xff\xfe\n");
+        b.extend_from_slice(format!("{}\n", json!({"display":"after","project":"/x","timestamp":2})).as_bytes());
+        std::fs::write(&p, b).unwrap();
+        assert_eq!(history_tail(&p).iter().map(|(_, d)| d.as_str()).collect::<Vec<_>>(), vec!["go", "after"]);
+    }
+
+    #[test]
+    fn hint_urgency_of_own_session_is_suggested_and_in_band() {
+        let (_t, home, cwd) = fixture();
+        let cd = home.join(".claude");
+        let reg: Registry = serde_json::from_value(json!({
+            "sessions": [{"name":"core","conversation_id":"abc","created":1,"last_active":2,
+                           "urgency":{"level":"high","note":"chờ Ship","set_at":3}}]
+        }))
+        .unwrap();
+        let mut cx = ctx(&home, &cwd, &cd);
+        cx.registry = Some(&reg);
+        cx.session_id = Some("abc");
+        assert_eq!(suggest(&cx, &gather(&cx)).as_deref(), Some("đã xem urgent high: chờ Ship; làm tiếp rồi 8sync ccc . urgent clear"));
+        write(&home.join(".local/state/8sync/watchdog/alerts.jsonl"), &format!("{}\n", json!({"ts": 999_900, "kind": "gpu-vram"})));
+        assert_eq!(band(&gather(&cx)), vec!["urgent high: chờ Ship · watchdog: gpu-vram".to_string()]);
+        cx.session_id = Some("other");
+        cx.now = 2_000_000;
+        assert!(band(&gather(&cx)).is_empty(), "no loop, no git, stale alert, not my urgency");
+    }
+
+    #[test]
+    fn hint_band_is_at_most_two_lines_and_json_contract_holds() {
+        let (_t, home, cwd) = fixture();
+        let cd = home.join(".claude");
+        write(&cwd.join("su-code/ship/ACTIVE"), "hints\n");
+        write(&cwd.join("su-code/ship/hints/loop.json"), r#"{"iter":1,"max_iter":4}"#);
+        write(&home.join(".local/state/8sync/watchdog/alerts.jsonl"), &format!("{}\n", json!({"ts": 1_000_000, "kind": "cpu"})));
+        let cx = ctx(&home, &cwd, &cd);
+        let v = render_hint(&cx);
+        assert_eq!(v, json!({ "suggest": "tiếp tục loop hints (iter 1/4)", "band": ["loop hints 1/4", "watchdog: cpu"] }));
+        assert!(v["band"].as_array().unwrap().len() <= 2);
+        let v = render_complete(&complete("/sh", &cx));
+        assert_eq!(v, json!({ "complete": [{ "text": "/ship", "label": "ship", "description": "Chạy trọn quy trình một feature." }] }));
+        assert_eq!(render_complete(&[]), json!({ "complete": [] }));
+    }
+
+    #[test]
+    fn hint_parse_git_status_v2() {
+        let out = "# branch.oid abc\n# branch.head feat/ccc-hints\n# branch.upstream origin/feat/ccc-hints\n# branch.ab +3 -0\n1 .M N... 100644 100644 100644 abc def crates/x.rs\n";
+        assert_eq!(parse_status(out), Git { branch: Some("feat/ccc-hints".into()), ahead: 3, dirty: true });
+        assert_eq!(parse_status("# branch.oid abc\n# branch.head (detached)\n"), Git::default());
+        assert_eq!(parse_status("# branch.oid abc\n# branch.head main\n# branch.ab +0 -2\n"), Git { branch: Some("main".into()), ahead: 0, dirty: false });
+        assert_eq!(parse_status("# branch.head main\n? new.rs\n"), Git { branch: Some("main".into()), ahead: 0, dirty: true }, "untracked counts as dirty");
+    }
+
+    #[test]
+    fn hint_real_git_repo_feeds_suggest_and_band() {
+        let (_t, home, cwd) = fixture();
+        let cd = home.join(".claude");
+        write(&cd.join("history.jsonl"), "");
+        git(&cwd, &["init", "-q", "-b", "main"]);
+        write(&cwd.join("a.txt"), "1\n");
+        git(&cwd, &["add", "."]);
+        git(&cwd, &["-c", "commit.gpgsign=false", "commit", "-q", "-m", "init"]);
+        let cx = ctx(&home, &cwd, &cd);
+        // A generous budget here: this checks what real git says, not how fast a loaded
+        // Windows runner spawns it (the latency test covers the production budget).
+        let slow = Duration::from_secs(20);
+        let f = Facts { git: git_status_within(&cwd, slow), ..gather(&cx) };
+        assert_eq!(f.git, Git { branch: Some("main".into()), ahead: 0, dirty: false });
+        assert_eq!(suggest(&cx, &f), None);
+        assert_eq!(band(&f), vec!["⎇ main".to_string()]);
+        write(&cwd.join("b.txt"), "2\n");
+        let f = Facts { git: git_status_within(&cwd, slow), ..gather(&cx) };
+        assert!(f.git.dirty, "untracked file: {f:?}");
+        assert_eq!(suggest(&cx, &f).as_deref(), Some("/sec rồi commit theo conventional commits"));
+        assert_eq!(band(&f), vec!["⎇ main ✎".to_string()]);
+    }
+
+    #[test]
+    fn hint_complete_slash_lists_skills_prefix_then_subsequence() {
+        let (_t, home, cwd) = fixture();
+        let cd = home.join(".claude");
+        let cx = ctx(&home, &cwd, &cd);
+        let rows = complete("/sh", &cx);
+        assert_eq!(rows[0], Row { text: "/ship".into(), label: "ship".into(), description: "Chạy trọn quy trình một feature.".into() });
+        let rows = complete("/", &cx);
+        assert_eq!(rows.len(), MAX_ROWS);
+        let rows = complete("/repo", &cx);
+        assert_eq!(rows[0].label, "repo-only", "repo skill without name: uses the folder name");
+        assert_eq!(rows[0].description, "skill của repo");
+        let rows = complete("/s1", &cx);
+        assert_eq!(rows.len(), MAX_ROWS);
+        assert!(rows.iter().all(|r| r.label.starts_with("sk1")), "11 prefix rows (sk1, sk10…) fill the cap before any subsequence row: {rows:?}");
+        let rows = complete("/sp", &cx);
+        assert_eq!(rows.iter().map(|r| r.label.as_str()).collect::<Vec<_>>(), vec!["ship"], "no prefix match: subsequence s…p finds ship only");
+        assert!(complete("/ship", &cx).is_empty(), "exact match: nothing to add");
+        assert!(complete("/home/alexng/x", &cx).is_empty(), "a path is not a skill query");
+        assert!(complete("plain text", &cx).is_empty());
+    }
+
+    #[test]
+    fn hint_complete_8sync_and_ccc_verbs() {
+        let (_t, home, cwd) = fixture();
+        let cd = home.join(".claude");
+        let cx = ctx(&home, &cwd, &cd);
+        let rows = complete("8sync ccc lo", &cx);
+        assert_eq!(rows[0], Row { text: "loop".into(), label: "loop".into(), description: CCC_VERBS.iter().find(|(v, _)| *v == "loop").unwrap().1.into() }, "partial last word: the verb replaces it");
+        let rows = complete("ccc ", &cx);
+        assert_eq!(rows.len(), MAX_ROWS);
+        assert_eq!(rows[0].text, rows[0].label, "after a space: the verb alone");
+        let rows = complete("ccc", &cx);
+        assert!(rows.iter().all(|r| r.text.starts_with("ccc ")), "the token is `ccc` itself: rows re-write it: {rows:?}");
+        let rows = complete("8sync cc", &cx);
+        assert!(rows.iter().any(|r| r.text == "ccc" && !r.description.is_empty()), "{rows:?}");
+        let rows = complete("8sync", &cx);
+        assert_eq!(rows.len(), MAX_ROWS);
+        assert!(rows.iter().all(|r| r.text.starts_with("8sync ")), "{rows:?}");
+        assert!(complete("8sync ccc loop", &cx).is_empty(), "exact verb: nothing to add");
+        assert!(complete("8sync ccc loop tick", &cx).is_empty(), "past the verb: no rows");
+    }
+
+    #[test]
+    fn hint_ccc_verbs_table_matches_dispatcher() {
+        for (v, d) in CCC_VERBS {
+            assert!(*v == "." || super::super::help::VERBS.contains(v), "{v} is not a dispatcher verb");
+            assert!(!d.is_empty());
+        }
+        for v in super::super::help::VERBS {
+            if matches!(*v, "list" | "rm" | "new") {
+                continue;
+            }
+            assert!(CCC_VERBS.iter().any(|(n, _)| n == v), "dispatcher verb {v} missing from CCC_VERBS");
+        }
+    }
+
+    #[test]
+    fn hint_parse_frontmatter_variants() {
+        assert_eq!(parse_frontmatter("---\nname: a\ndescription: \"B. C\"\n---\n", "f"), ("a".into(), "B.".into()));
+        assert_eq!(parse_frontmatter("# no frontmatter", "f"), ("f".into(), String::new()));
+        assert_eq!(parse_frontmatter("---\nname:\n---\n", "f"), ("f".into(), String::new()));
+        assert_eq!(parse_frontmatter("\u{feff}---\nname: bom\n---\n", "f"), ("bom".into(), String::new()));
+        assert_eq!(parse_frontmatter("---\nname: blk\ndescription: >\n  folded text\n---\n", "f"), ("blk".into(), String::new()), "block scalar: no marker shown");
+    }
+
+    /// The real path: a git repo, 41 skills, a 512 KiB history tail and both outputs. Our own
+    /// work stays under 50 ms; with git on, the call also waits for one `git status`.
+    #[test]
+    fn hint_latency_under_50ms_on_fixture() {
+        let (_t, home, cwd) = fixture();
+        let cd = home.join(".claude");
+        let mut s = String::new();
+        let proj = cwd.to_string_lossy().to_string();
+        while s.len() < HISTORY_TAIL as usize {
+            s.push_str(&format!("{}\n", json!({"display":"chạy test rồi báo","project":proj,"timestamp":1})));
+            s.push_str(&format!("{}\n", json!({"display":"commit đi","project":proj,"timestamp":2})));
+        }
+        write(&cd.join("history.jsonl"), &s);
+        write(&cwd.join("su-code/ship/ACTIVE"), "hints\n");
+        write(&cwd.join("su-code/ship/hints/loop.json"), r#"{"iter":1,"max_iter":4}"#);
+        git(&cwd, &["init", "-q", "-b", "main"]);
+        git(&cwd, &["add", "."]);
+        git(&cwd, &["-c", "commit.gpgsign=false", "commit", "-q", "-m", "init"]);
+        let mut cx = ctx(&home, &cwd, &cd);
+        cx.git = true;
+        let _ = (render_hint(&cx), complete("/s", &cx)); // warm the page cache
+        let t0 = Instant::now();
+        for _ in 0..5 {
+            let v = render_hint(&cx);
+            assert!(v["band"][0].as_str().unwrap().starts_with("loop hints 1/4"), "{v}");
+            let _ = complete("/s", &cx);
+            let _ = complete("8sync ccc ", &cx);
+        }
+        let per = t0.elapsed() / 5;
+        assert!(per < Duration::from_millis(50) + GIT_BUDGET, "one hint call took {per:?}");
+        cx.git = false;
+        let t0 = Instant::now();
+        for _ in 0..5 {
+            let _ = render_hint(&cx);
+            let _ = complete("/s", &cx);
+            let _ = complete("8sync ccc ", &cx);
+        }
+        let per = t0.elapsed() / 5;
+        assert!(per < Duration::from_millis(50), "hint without git took {per:?}");
+    }
+}
diff --git a/crates/cli/src/verbs/ccc/statusline.rs b/crates/cli/src/verbs/ccc/statusline.rs
index 83c400b4..6e5af825 100644
--- a/crates/cli/src/verbs/ccc/statusline.rs
+++ b/crates/cli/src/verbs/ccc/statusline.rs
@@ -279,7 +279,7 @@ fn kill_group(pgid: u32) {
 /// Run `cmd` in its own process group, give it `budget`; on timeout kill the whole group (a
 /// `sh -c 'a | b'` chain included) and return `None`. stdin is fed and stdout drained on threads,
 /// so neither a full pipe nor a child that ignores stdin can stall us past the budget.
-fn run_budget(mut cmd: Command, stdin: Option<&str>, budget: Duration) -> Option<String> {
+pub(super) fn run_budget(mut cmd: Command, stdin: Option<&str>, budget: Duration) -> Option<String> {
     cmd.stdin(if stdin.is_some() { Stdio::piped() } else { Stdio::null() }).stdout(Stdio::piped()).stderr(Stdio::null());
     #[cfg(unix)]
     std::os::unix::process::CommandExt::process_group(&mut cmd, 0);
diff --git a/crates/cli/src/verbs/completions.rs b/crates/cli/src/verbs/completions.rs
new file mode 100644
index 00000000..3678e0e3
--- /dev/null
+++ b/crates/cli/src/verbs/completions.rs
@@ -0,0 +1,66 @@
+//! `8sync completions <shell>`: print a tab-completion script for the `8sync` command tree.
+//! Generated from the same clap tree `main` parses (brand-rewritten), so every verb, alias and
+//! flag completes exactly as the binary accepts it. Install (bash example):
+//! `8sync completions bash > ~/.local/share/bash-completion/completions/8sync`.
+
+use std::io::Write;
+
+use anyhow::Result;
+use clap::Args as ClapArgs;
+use clap_complete::Shell;
+
+#[derive(ClapArgs, Debug)]
+#[command(after_help = indoc::indoc! {"
+EXAMPLES
+  8sync completions bash > ~/.local/share/bash-completion/completions/8sync
+  8sync completions zsh  > ~/.zfunc/_8sync          # fpath+=(~/.zfunc); autoload -U compinit
+  8sync completions fish > ~/.config/fish/completions/8sync.fish
+  8sync completions powershell >> $PROFILE
+"})]
+pub struct Args {
+    /// Shell to generate for
+    #[arg(value_enum)]
+    pub shell: Shell,
+}
+
+pub fn run(a: Args) -> Result<()> {
+    let mut out = Vec::new();
+    generate(a.shell, &mut out);
+    std::io::stdout().write_all(&out)?;
+    Ok(())
+}
+
+/// The script for `shell`, into `out`.
+pub(crate) fn generate(shell: Shell, out: &mut Vec<u8>) {
+    let mut cmd = crate::command();
+    let name = cmd.get_name().to_string();
+    clap_complete::generate(shell, &mut cmd, name, out);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn script(shell: Shell) -> String {
+        let mut out = Vec::new();
+        generate(shell, &mut out);
+        String::from_utf8(out).unwrap()
+    }
+
+    #[test]
+    fn completions_bash_lists_ccc_and_itself() {
+        let s = script(Shell::Bash);
+        assert!(s.contains("ccc"), "bash script must complete the ccc verb");
+        assert!(s.contains("completions"));
+        assert!(s.contains("8sync"));
+    }
+
+    #[test]
+    fn completions_every_shell_generates() {
+        for sh in [Shell::Zsh, Shell::Fish, Shell::PowerShell, Shell::Elvish] {
+            let s = script(sh);
+            assert!(s.len() > 1000, "{sh:?} script too short: {} bytes", s.len());
+            assert!(s.contains("ccc"), "{sh:?} lacks ccc");
+        }
+    }
+}
diff --git a/crates/cli/src/verbs/mod.rs b/crates/cli/src/verbs/mod.rs
index a3b09f48..2417b2de 100644
--- a/crates/cli/src/verbs/mod.rs
+++ b/crates/cli/src/verbs/mod.rs
@@ -40,3 +40,4 @@ pub mod uuid_sessions;
 pub mod session_view;
 pub mod session_cmds;
 pub mod secret_mask;
+pub mod completions;
diff --git a/research/omp-features.md b/research/omp-features.md
new file mode 100644
index 00000000..c0d9fb5f
--- /dev/null
+++ b/research/omp-features.md
@@ -0,0 +1,75 @@
+# omp vs ccc: feature scan (2026-10-16)
+
+Tóm tắt: quét `omp` v18.11.1 (`omp --help`, CHANGELOG, `~/.omp/capabilities.md` snapshot v18.8.7) so với ccc (`8sync ccc help`, `help.rs`, CHANGELOG 8sync 0.92.1). ccc đã có session/goal/urgent/standup/loop/report/statusline/compact/policy/idle/delegate/secret/kit và HQ UI. Khoảng trống lớn nhất nằm ở lớp nhập liệu (ghost text, typeahead, gợi ý cho composer rỗng, shell completion). Đây là phần port đợt này. Các tính năng liên quan token subscription, proxy, account pool, provider auth thì không port. Mô tả omp lấy từ help/CHANGELOG (chưa đọc source, not verified).
+
+## Licence
+
+- omp là MIT (Mario Zechner, Can Bölük, Stencil Labs, Inc.; nguồn: LICENSE trong package).
+- ccc chỉ port ý tưởng, tự viết Rust trong `8sync`, không copy code.
+- Claude Code không bị sửa hay reverse-engineer; ccc chỉ dùng extension point chính thức: settings hooks, skills, agents, MCP, statusline, và plugin API mới (function hooks / mods: prompt.autocomplete, $.prompt.suggest, ui.render AbovePrompt).
+
+## Bảng so sánh
+
+| Feature | omp | ccc hiện có | Port? | Ghi chú / rule |
+|---|---|---|---|---|
+| Predictive text / word completion | engine N-gram + SmolLM2 + macOS native, daemon, `omp predict` | không | đợt này | N-gram Rust từ prompt history local của owner; bỏ SmolLM2 (model tải về, nặng) |
+| Composer predictions (ghost text tin nhắn kế) | `composer.predictions`, Tab/Right nhận; tốn thêm 1 request model | không | đợt này | ccc-hint chạy local từ history, không gọi model thêm |
+| Context-aware suggestion (composer rỗng) | gợi ý theo ngữ cảnh turn | không | đợt này | `$.prompt.suggest` từ loop đang mở / urgent của session / bigram lịch sử prompt (local) / trạng thái git |
+| Slash command completions + mô tả | typeahead trong TUI | skill liệt kê của Claude Code | đợt này | `prompt.autocomplete` trả hàng kèm description (skill, verb 8sync) |
+| Shell completion | `omp completions` (bash/zsh/fish) | không | đợt này | `8sync completions` sinh từ clap |
+| /effort, --thinking | `--thinking off..max,auto` | `claude --effort`/model của Claude Code | đã có | flag sau tên session đi thẳng vào claude (`8sync ccc . <tên> ...`) |
+| Advisor (passive turn reviewer) | `--advisor` chèn note mỗi turn | hook Stop `verify-stop` + agents `reviewer`/`critic` | đã có | mức thấp hơn: không review từng turn; đợt sau: hook Stop gọi reviewer nhẹ |
+| Prewalk / plan-yolo handoff | đổi sang model rẻ ở edit đầu | không | không | điều hướng model/token theo luồng; chọn model là việc của Claude Code, ngoài phạm vi |
+| smol/slow/plan model roles | `--smol/--slow/--plan` | agent frontmatter `model:` trong kit | đã có | agent kit chọn model qua frontmatter chính thức |
+| Goal mode | `--goal` | `8sync ccc . goal`, `/ship-loop`, `loop.json` | đã có | ccc goal ghi mục tiêu + file giữ |
+| --restore (làm nốt turn dang dở) | resume + chạy lại subagent bị ngắt | `claude --resume`, `ccc .`, hook `resume-note` | đợt sau | verb `8sync ccc restore`: đọc transcript + loop.json, in lệnh resume; không tự chạy lại tool |
+| Session fork/branch/pane | `/fork pane/window/tab` | `--team --panes` (tmux) | đợt sau | verb fork bọc `claude --fork-session`; HQ mở pane |
+| /btw side questions | hỏi chen không phá turn | không | đợt sau | mod ui.render AbovePrompt hoặc agent `quick-task`; xem API mods |
+| Background jobs view | `/jobs`, job tree, `omp ps` | HQ UI, statusline `--agents`, `ccc . ls` | đã có | HQ + `8sync ccc statusline --agents` |
+| Agent lineage HUD | cây job/subagent | `8sync ccc standup`, HQ office | đã có | standup 7 role + HQ |
+| Account pools / OAuth balancing | `dry-balance`, auth-broker | không | không | token subscription routing; cấm theo rule Anthropic |
+| Auth gateway (HTTP forward proxy) | `omp auth-gateway` | không | không | proxy + dùng chung credential; cấm |
+| RPC/SDK/ACP mode | `--mode rpc`, `omp acp` | `claude -p`, Agent SDK chính thức | không | dùng SDK chính thức của Anthropic, không dựng server riêng |
+| --from-claude import | nhập session Claude Code vào omp | không | không | đẩy transcript sang client khác; ngoài phạm vi |
+| worktree.onStart / `omp worktree` | hook khi tạo worktree | EnterWorktree + hook SessionStart | đợt sau | hook WorktreeCreate gọi `8sync` setup (cài deps nhẹ); verb `8sync wt` |
+| Prompt-cache warming | replay request trước khi cache hết hạn | `ccc compact --at` giữ 60% | không | replay request = tốn token subscription ngoài ý định; Claude Code tự quản cache |
+| Usage-limit tracking / `omp usage` | hiển thị limit mọi account | statusline (usage), `ccc report` | đã có | chỉ số Claude Code báo qua statusline; không hỏi API subscription |
+| Secret obfuscation/redaction | redact secret trong transcript | hook `guard` + `/sec` + `ccc secret` | đã có | giá trị không vào transcript |
+| Memory (hindsight/mnemopi) | retain/recall/reflect | `/remember`, `su-code/KNOWLEDGE.md`, digest SessionStart | đã có | file local, không server trung tâm |
+| Headroom compression | MCP compress output | `ccc compact`, ví dụ `8sync` verb lọc output | đợt sau | `8sync run` rút gọn log dài; MCP headroom của omp không nằm trong kit (not verified) |
+| LSP tools | `lsp` tool | LSP plugin Claude Code, `codegraph` | đã có | CLAUDE.md ưu tiên codegraph/LSP |
+| Skills discovery | `--skills`, skillshare | kit skills, `8sync skill learn` | đã có | `8sync skill learn` kiểm licence trước |
+| Rules discovery | `--no-rules`, context files | CLAUDE.md/AGENTS.md, `/rules` | đã có | kit nạp qua `ccc kit` |
+| Hooks/extensions | `--hook`, `-e`, plugin | settings hooks + `8sync ccc hook ...` + mods | đã có | chỉ API chính thức |
+| Voice, autoGraph, wait tool, keybindings | TTS/STT, find, wait, phím | Monitor, codegraph, keybindings.json | không | voice ngoài phạm vi; ba mục còn lại đã có bằng công cụ chính thức |
+| /record, `omp stream`, `omp clip`, `play` | quay + phát lên live.omp.sh | không | không | đẩy màn hình/chat ra dịch vụ ngoài; rủi ro data |
+| anonymize / session dump / `omp share` | bản chia sẻ đã ẩn danh | `/sec`, anonymize trong skill | đợt sau | `8sync session anon` Rust: thay path/literal bằng token; chỉ xuất file local |
+| gc --compress | nén session cũ bằng FS | `ccc rm` | đợt sau | `8sync clean` thêm session cũ; không đổi định dạng transcript |
+| task.structured / yield schema | kết quả subagent theo schema | agents kit trả ≤10 bullet | đợt sau | JSON schema trong brief + verifier agent |
+| Subagent completion estimates | ước lượng hoàn thành | `ccc report` (cost/task) | đợt sau | HQ tính từ lịch sử `report`, không bịa số |
+
+## Port đợt này (ccc-hints)
+
+- `8sync ccc hint`: Rust verb; đọc prompt history local của chính owner (`~/.claude/history` qua đường dẫn chính thức, chưa verify định dạng), dựng N-gram, trả JSON `{ghost, rows[]}` cho một prefix. Dữ liệu không rời máy, không gọi model.
+- Mod `8sync-hints` (plugin API chính thức): `prompt.autocomplete` hiện ghost text + hàng typeahead kèm description (skill, verb `8sync`, session). Gọi `8sync ccc hint --json`.
+- Composer rỗng: `$.prompt.suggest` đề xuất tin kế từ loop đang mở, urgent của session, bigram lịch sử prompt local, trạng thái git. Gợi ý theo luật, không tốn token.
+- `8sync completions <bash|zsh|fish|powershell>`: sinh từ clap, chạy trên Windows/macOS/Linux; có test snapshot. Không build nặng ở máy owner: chạy CI.
+
+## Port đợt sau, ưu tiên
+
+1. `8sync ccc restore`: đọc transcript + `loop.json`, in lệnh `claude --resume`; hook `resume-note` đã có sẵn.
+2. Hook Stop gọi reviewer nhẹ (advisor): hook chính thức + agent `reviewer`, bật/tắt như `idle`/`delegate`.
+3. `/fork` bọc `claude --fork-session`, HQ mở pane (tmux) cho fork.
+4. Hook WorktreeCreate: `8sync` setup nhanh cho worktree mới (deps, env mẫu, không copy secret).
+5. `8sync session anon`: ẩn danh path/literal cho bản chia sẻ nội bộ, ghi file local.
+6. HQ: ước lượng thời gian/cost theo task từ lịch sử `ccc report` (chỉ số đo thật, nêu nguồn).
+
+## Không port
+
+- Account pools, `dry-balance`, auth-broker, `omp auth/token/login`: token subscription routing / provider auth.
+- `auth-gateway`: forward proxy dùng credential chung; rule cấm.
+- Prompt-cache warming, prewalk, plan-yolo, `--external-thinking`: đổi model/ép request ngoài Claude Code, provider đã gắn cờ abuse với `--external-thinking`.
+- `--from-claude/--from-codex`, RPC/ACP server riêng: sao chép session, dựng client thay Claude Code; ngoài phạm vi.
+- `/record`, `stream`, `clip`, `share`: đẩy màn hình/chat ra dịch vụ ngoài (rủi ro data client).
+- Voice/TTS/STT, `computer`, `browser-relay`: ngoài phạm vi.
+- Mọi tính năng omp cần server trung tâm giữ data người dùng: trái nguyên tắc local-first.
diff --git a/scripts/uat/hints-load.sh b/scripts/uat/hints-load.sh
new file mode 100755
index 00000000..953d5738
--- /dev/null
+++ b/scripts/uat/hints-load.sh
@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# UAT: the 8sync-hints mod loads in the official `claude` binary. Headless `claude -p` with
+# `--plugin-dir` prints one stderr line naming a plugin whose module failed to load; a clean run
+# prints none. Also checks `8sync ccc hint --json` answers from a repo (the mod's only dependency).
+# Usage: scripts/uat/hints-load.sh [MOD_DIR=assets/claude/skills/8sync-hints]
+# Exit 0 = pass, 1 = mod failed to load / hint broken, 2 = setup error.
+set -uo pipefail
+ROOT="$(cd "$(dirname "$0")/../.." && pwd -P)"
+MOD="${1:-$ROOT/assets/claude/skills/8sync-hints}"
+for c in claude 8sync python3; do command -v "$c" >/dev/null || { echo "missing $c"; exit 2; }; done
+[ -f "$MOD/.claude-plugin/plugin.json" ] || { echo "no mod at $MOD"; exit 2; }
+
+T=$(mktemp -d -t uat-hints.XXXXXX); trap 'rm -rf "$T"' EXIT
+ERR="$T/stderr.txt"
+# A prompt the model answers in one short turn; the mod loads before the turn starts.
+claude -p "Reply with the single word OK." --plugin-dir "$MOD" --model claude-haiku-5-5 --max-turns 1 \
+  >"$T/stdout.txt" 2>"$ERR"
+code=$?
+if grep -i "8sync-hints" "$ERR" | grep -Eiq "fail|refus|not loaded|error"; then
+  echo "FAIL: engine refused the mod:"; grep -i "8sync-hints" "$ERR"; exit 1
+fi
+[ "$code" -eq 0 ] || { echo "FAIL: claude -p exited $code"; tail -5 "$ERR"; exit 1; }
+
+# The Rust side the mod calls: JSON with suggest + band, and typeahead rows for `/`.
+cd "$ROOT" || exit 2
+8sync ccc hint --json >"$T/hint.json" || { echo "FAIL: 8sync ccc hint --json exited $?"; exit 1; }
+python3 -I - "$T/hint.json" <<'PY' || exit 1
+import json, sys
+v = json.load(open(sys.argv[1]))
+assert "suggest" in v and isinstance(v["band"], list) and len(v["band"]) <= 2, v
+print("hint ok:", json.dumps(v, ensure_ascii=False)[:160])
+PY
+8sync ccc hint --complete /sh --json | python3 -I -c 'import json,sys; v=json.load(sys.stdin); assert any(r["text"]=="/ship" for r in v["complete"]), v; print("complete ok:", len(v["complete"]), "rows")' || exit 1
+echo "PASS: 8sync-hints loads in claude -p and 8sync ccc hint answers"
diff --git a/su-code/KNOWLEDGE.md b/su-code/KNOWLEDGE.md
index acfa388e..d0253e2c 100644
--- a/su-code/KNOWLEDGE.md
+++ b/su-code/KNOWLEDGE.md
@@ -466,3 +466,5 @@ _(consolidated 72 dòng cũ → su-code/archive/KNOWLEDGE-1790603711.md)_
 - validated: GitHub REST `search/repositories` (`created:>DATE stars:>50`, sort=stars, unauthenticated, 1 call/run) is a good-enough "trending" without scraping github.com/trending (ToS); star-sorted results include adult-content repos, so filter names/descriptions before handing the list to an R&D session. 2026-10-15
 - failure: a new `FloorState` (`meeting`) was added to `deriveFloor` + LABEL + sprite clips, tests passed, yet the office never drew it: `seatState()` in lib/office.ts has its own `known` list and floor.ts has `ACTIVE`/`WORKING` sets — three more places. Guard: when adding a FloorState, grep `"done"` in apps/hq-ui/lib and update every list; add a `seatState`/`groupFloor` assertion, not only a deriveFloor one. (reviewer on 91ad7b0, 2026-10-15)
 - validated: `DirEntry::file_type()` does not follow symlinks while `Path::is_file()` does — any verb that copies a file out of an untrusted clone into `~/.claude` must use the former (skill learn symlink test, 2026-10-15).
+- validated: Claude Code 2.1.301 "function hooks" mods are the sanctioned way to draw inside the prompt (skill `plugin-authoring`): `prompt.autocomplete` rows replace the TOKEN under the cursor (so "8sync ccc lo" → text "loop", not the whole line), `$.prompt.suggest` is ghost text the engine itself hides while the box has text, `ui.render {component:'AbovePrompt'}` is the band. `claude plugin validate` refuses a helper that takes `$` unless it is a top-level function (not a closure inside `register`); in `claude plugin test` a bottom hook answers `process.run` with `{ value: {exitCode,stdout,stderr,isStdoutTruncated,isStderrTruncated} }`, `session.start` with `{ cwd }`, `ui.render` with `$.ui.resolve(e).Text({children})`; `$.state` is session-wide across surfaces, so press "hide" after mounting every surface. A plugin folder under `~/.claude/skills/<name>` auto-loads → ship mods through KIT_FILES. (ccc-hints, 2026-10-16)
+- validated: omp's "predictive composer" is just a bigram over the owner's own history — `~/.claude/history.jsonl` (`display`, `project`, `timestamp`) gives the same locally in < 10 ms (`8sync ccc hint`); no model, no network, nothing leaves the machine, and the Consumer-terms question never arises because the mod runs inside the official client. 2026-10-16
diff --git a/su-code/ship/ccc-hints/LOOP.md b/su-code/ship/ccc-hints/LOOP.md
new file mode 100644
index 00000000..71e67b23
--- /dev/null
+++ b/su-code/ship/ccc-hints/LOOP.md
@@ -0,0 +1,45 @@
+# ccc-hints — LOOP (max-iter 12 · max-min 90)
+
+| # | Criterion | Lệnh |
+|---|---|---|
+| C1 | hint rules + latency | `nice -n 19 ionice -c3 cargo test -q -j2 -p su-code hint_` |
+| C2 | mod validate | `claude plugin validate assets/claude/skills/8sync-hints` |
+| C3 | mod tests | `claude plugin test assets/claude/skills/8sync-hints` |
+| C4 | completions | `nice -n 19 ionice -c3 cargo test -q -j2 -p su-code completions_` |
+| C5 | kit installs mod | `nice -n 19 ionice -c3 cargo test -q -j2 -p su-code kit_` |
+| C6 | mod loads in claude -p | `bash scripts/uat/hints-load.sh` |
+| C7 | omp feature scan doc | `test -s research/omp-features.md && [ "$(grep -c '^| ' research/omp-features.md)" -ge 30 ] && grep -q MIT research/omp-features.md` |
+| C8 | clippy touched files | see PLAN |
+| C9 | CI 3 OS | `gh run watch <id> --exit-status` |
+
+## Evidence
+iter 0 | C1 | exit 101 | error: test failed, to rerun pass `-p su-code --bin 8sync`
+iter 0 | C1 | exit 0 | test result: ok. 11 passed; 0 failed; 0 ignored; 0 measured; 475 filtered out; finished in 0.01s
+iter 0 | C4 | exit 0 | test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 483 filtered out; finished in 0.01s
+iter 0 | C7 | exit 0 | (no output)
+iter 1 | C2 | exit 0 | ✔ Validation passed
+iter 1 | C3 | exit 0 | Ran 7 tests across 1 file. [0.26s]
+iter 1 | C1 | exit 0 | test result: ok. 11 passed; 0 failed; 0 ignored; 0 measured; 476 filtered out; finished in 0.00s
+iter 1 | C5 | exit 0 | test result: ok. 18 passed; 0 failed; 0 ignored; 0 measured; 469 filtered out; finished in 0.02s
+iter 1 | C4 | exit 0 | test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 484 filtered out; finished in 0.01s
+iter 1 | C8 | exit 0 | (no output)
+iter 1 | C6 | exit 0 | PASS: *** loads in claude -p and 8sync ccc hint answers
+
+## D — review gates (iter 1, 2026-10-16)
+- `/sec`: gitleaks 8.x `--no-git` on the 23 diff/untracked files → "no leaks found"; the 15 hits of a full-tree scan are pre-existing test fixtures (secret_mask.rs, transcript.rs, hq.rs) and the ignored `apps/hq-ui/.next` dev cache. Regex on diff: none. Sensitive files: only `assets/configs/kitty.session` (pre-existing, not read). `cargo audit`: RUSTSEC-2026-0190 (anyhow, parked). Kit status: 29/29 · guard · gates on. New code: no unsafe/eval/http/shell. → OK.
+- `/rules` (rules file "Cập nhật: 2026-10-11"): ALLOWED — the mod is a Claude Code plugin through the documented function-hooks API (code.claude.com/docs/en/plugins), runs inside the owner's own official client (subscription token never leaves Claude Code, no proxy/fake client — AUP "Do Not Abuse Our Platform" not touched); `hint` reads only the owner's own local files (history.jsonl, skills, ship, registry) and sends nothing anywhere.
+- `/aup-audit` on the diff: no AUP signal (RULES.md table) — no PII, scraping, mass contact, impersonation; the one new data read (local prompt history) stays on the machine and is disclosed in CHANGELOG. → no BLOCK/WARN.
+iter 1 | C1 | exit 0 | test result: ok. 14 passed; 0 failed; 0 ignored; 0 measured; 476 filtered out; finished in 0.05s
+iter 1 | C4 | exit 0 | test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 487 filtered out; finished in 0.01s
+iter 1 | C5 | exit 0 | test result: ok. 18 passed; 0 failed; 0 ignored; 0 measured; 472 filtered out; finished in 0.02s
+iter 1 | C2 | exit 0 | ✔ Validation passed
+iter 1 | C3 | exit 0 | Ran 8 tests across 1 file. [0.30s]
+iter 1 | C7 | exit 0 | (no output)
+iter 1 | C6 | exit 0 | PASS: *** loads in claude -p and 8sync ccc hint answers
+iter 1 | C1 | exit 0 | test result: ok. 14 passed; 0 failed; 0 ignored; 0 measured; 476 filtered out; finished in 0.05s
+iter 1 | C8 | exit 0 | (no output)
+iter 1 | C9 | exit 1 | package-hq-ui: .github#1
+iter 2 | C9 | exit 0 | test (ubuntu-latest): .github#1
+
+## Kết thúc (iter 2, 2026-10-16)
+Tất cả C1–C9 xanh. C9: CI run 38837734481 đỏ trên Windows (git status > 50 ms) → fix 7762610 (GIT_BUDGET 300 ms) → run 38838076659 xanh 3 OS. Reviewer (NOT MERGEABLE → 1 BLOCKER + 8 SHOULD + NIT) và QA UAT (2 FAIL: UTF-8 history, untracked dirty) đã sửa hết. Not verified: dòng `/` trùng menu engine ở đầu ô (đã bỏ start=0); ghost text trong phiên thật cần restart.
diff --git a/su-code/ship/ccc-hints/PLAN.md b/su-code/ship/ccc-hints/PLAN.md
new file mode 100644
index 00000000..c9ee0cc6
--- /dev/null
+++ b/su-code/ship/ccc-hints/PLAN.md
@@ -0,0 +1,73 @@
+# ccc-hints — gợi ý realtime trong prompt của ccc (như omp), tab completion, quét omp → port native Rust
+
+Owner (2026-10-16): "enhance prompt in ccc can auto hint real time like omp suggestion to tab completion, scan all omp
+rights? move all feat strong harness to ccc native rust follow /rules /aup-audit /sec".
+
+Đọc: (1) prompt của Claude Code trong ccc phải có gợi ý realtime như omp: ghost text (Tab để lấy), typeahead khi gõ `/…`
+và dải hint trên prompt; (2) tab completion cho lệnh `8sync` ngoài shell; (3) quét hết feature mạnh của omp, cái nào
+port được thì port sang ccc bằng Rust native (không copy code omp, chỉ ý tưởng), tuân /rules /aup-audit /sec.
+
+## Đường hợp lệ (R&D, đã đọc API)
+- Claude Code 2.1.301 có **function hooks / mods** chính thức (skill `plugin-authoring`, types `claude-code.d.ts`):
+  `prompt.autocomplete` (hàng typeahead cho token ở con trỏ), `$.prompt.suggest` (ghost text, Tab/→ để lấy),
+  `ui.render { component: 'AbovePrompt' }` (dải trên prompt), `$.process.run(argv)` (gọi lệnh host, không shell),
+  `$.clock.every`. Một plugin đặt trong `~/.claude/skills/<name>` được **auto-load** (reference.md "Developing one").
+  → mod `8sync-hints` chỉ là lớp vẽ mỏng; mọi tính toán nằm trong `8sync ccc hint` (Rust native, < 50 ms).
+- Không reverse-engineer/copy prompt Claude Code; không proxy. omp = MIT (Zechner/Bölük/Stencil) nhưng ta **không copy
+  code**, chỉ port ý tưởng (predictive text n-gram từ lịch sử prompt của chính owner, context-aware suggestion khi
+  composer trống, typeahead có mô tả).
+
+## Goal
+1. **`8sync ccc hint [--complete <token>] [--json]`** (Rust, `crates/cli/src/verbs/ccc/hint.rs`), chạy trong repo hiện
+   tại, không mạng, không gọi `gh`:
+   - `suggest`: một câu gợi ý prompt kế (ghost text). Ưu tiên: loop `/ship-loop` đang mở trong `su-code/ship/ACTIVE`
+     → "tiếp tục loop <slug> (iter k/N)"; urgent của phòng (`8sync ccc . urgent`) → nhắc; **bigram từ
+     `~/.claude/history.jsonl`** (prompt owner đã gõ sau prompt giống lần trước, lọc theo project — port ý tưởng
+     omp `predict ngram`, local-only); nhánh có commit chưa push → "push nhánh + mở PR"; cây bẩn → "/sec rồi commit".
+   - `band`: ≤ 2 dòng ngắn cho dải trên prompt (loop · git · urgent · cảnh báo watchdog < 10 phút), tiếng Việt.
+   - `complete`: token bắt đầu `/` → skill đã cài (`~/.claude/skills/*/SKILL.md` + `.claude/skills` của repo,
+     frontmatter name/description, đọc ≤ 2 KB mỗi file), token bắt đầu `8sync`/`ccc` → verb của 8sync (bảng tĩnh).
+     Khớp prefix trước, rồi subsequence; ≤ 8 hàng `{text,label,description}`.
+2. **Mod `8sync-hints`** (`assets/claude/skills/8sync-hints/`: `.claude-plugin/plugin.json`, `hooks/hooks.json`,
+   `hooks/register.ts`, `hooks/hint.ts` thuần, `hooks/hint.test.ts`, `types/index.d.ts`): `session.start` +
+   `turn.complete` + `$.clock.every(20 s)` khi rảnh → `8sync ccc hint --json` → `$.prompt.suggest` + cập nhật band;
+   `prompt.autocomplete` token `^/`|`^8sync`|`^ccc` → `8sync ccc hint --complete <token> --json`; `ui.render
+   AbovePrompt` vẽ band dim + nút "Ẩn". Lỗi/không có `8sync` → im lặng (`next(e)`), không bao giờ chặn prompt.
+   Cài qua `8sync ccc kit` (KIT_FILES) vào `~/.claude/skills/8sync-hints` → mọi phiên ccc đang dùng nhận sau restart.
+3. **`8sync completions <bash|zsh|fish|powershell|elvish>`** (clap_complete) — tab completion cho lệnh `8sync` ở shell.
+4. **`research/omp-features.md`**: quét feature omp 18.11.1 (`--help`, CHANGELOG, capabilities.md) → bảng ≥ 30 dòng
+   `feature | omp | ccc hiện có | port? | ghi chú/rule`, phần "port đợt này" và "đợt sau", licence note (MIT, chỉ ý tưởng).
+5. CHANGELOG, `ccc help` cập nhật, `/sec` + `/rules` + `/aup-audit` (đọc lịch sử prompt local của chính owner: dữ liệu
+   ở máy owner, không gửi đi đâu).
+
+## Non-goals
+- Không sửa UI Claude Code ngoài API mod chính thức; không chạy model từ mod; không gọi mạng trong `hint`.
+- Không port: account pools, auth gateway, RPC/SDK, livestream, voice/TTS, codex/openai-specific (ngoài phạm vi hoặc
+  chạm điều khoản subscription).
+- Không build release local; CI 3 OS.
+
+## Acceptance criteria (exit 0 = pass; chạy trong /home/alexng/tools/su-code-hq, nhánh feat/ccc-hints)
+| # | Criterion | Lệnh |
+|---|---|---|
+| C1 | `hint`: suggest theo loop/urgent/bigram/git, band ≤ 2 dòng, complete `/`+`8sync` từ fixture; mỗi lần tính < 50 ms trên fixture | `nice -n 19 ionice -c3 cargo test -q -j2 -p su-code hint_` |
+| C2 | Mod hợp lệ theo engine: `claude plugin validate` không lỗi | `claude plugin validate assets/claude/skills/8sync-hints` |
+| C3 | Test mod (`claude-code/testing`): parse JSON của `hint`, hàng autocomplete, band tree, im lặng khi lỗi | `claude plugin test assets/claude/skills/8sync-hints` |
+| C4 | `8sync completions bash` sinh script có `ccc`; `zsh`/`fish`/`powershell` không panic | `nice -n 19 ionice -c3 cargo test -q -j2 -p su-code completions_` |
+| C5 | Kit cài mod: KIT_FILES có 5 file của mod, `install_kit_at` ghi `skills/8sync-hints/hooks/register.ts` | `nice -n 19 ionice -c3 cargo test -q -j2 -p su-code kit_` |
+| C6 | Mod load thật trong `claude -p` với `--plugin-dir` (không dòng stderr "8sync-hints … not loaded/failed") | `bash scripts/uat/hints-load.sh` |
+| C7 | `research/omp-features.md` ≥ 30 dòng bảng + mục licence | `test -s research/omp-features.md && [ "$(grep -c '^| ' research/omp-features.md)" -ge 30 ] && grep -q MIT research/omp-features.md` |
+| C8 | Clippy sạch trong file nhánh này chạm | `! (nice -n 19 ionice -c3 cargo clippy -q -j2 -p su-code --all-targets 2>&1 \| grep -E 'crates/cli/src/(verbs/ccc/hint.rs\|verbs/completions.rs\|verbs/ccc.rs\|main.rs)')` |
+| C9 | CI nhánh `feat/ccc-hints` xanh 3 OS | `gh run watch <id> --exit-status` |
+
+## Tasks (đợt; ≤ 2 writer song song vì watchdog báo GPU áp lực)
+- Đợt 1: lead viết `hint.rs` (C1) + `completions` (C4) + nối dispatch/help; **task** (subagent) viết
+  `research/omp-features.md` (C7) từ `omp --help`, CHANGELOG omp, capabilities.md — file tách bạch.
+- Đợt 2: lead viết mod `8sync-hints` (C2, C3, C6) + KIT_FILES (C5); clippy (C8); push → CI (C9).
+- Đợt 3: reviewer + qa UAT + `/sec` + `/rules` + `/aup-audit`; CHANGELOG; commit (không push main — không có `--release`).
+
+## Giả định (owner không hỏi được; chọn an toàn)
+- Band tiếng Việt, ≤ 2 dòng, có nút Ẩn; ghost text chỉ khi ô trống (engine tự đảm bảo).
+- Bigram đọc `~/.claude/history.jsonl` (dữ liệu của chính owner, local). Không ghi file nào mới ngoài cache skill index.
+- Mod đặt trong `~/.claude/skills/8sync-hints` (auto-load, không cần `--plugin-dir`); phiên đang mở cần restart.
+- "scan all omp rights" = quét toàn bộ feature mạnh của omp; đợt này port: ghost-text/predict, typeahead có mô tả,
+  context-aware suggestion, shell completion. Các feature còn lại ghi vào bảng "đợt sau".
diff --git a/su-code/ship/ccc-hints/SPRINT.md b/su-code/ship/ccc-hints/SPRINT.md
new file mode 100644
index 00000000..034113da
--- /dev/null
+++ b/su-code/ship/ccc-hints/SPRINT.md
@@ -0,0 +1,6 @@
+# Sprint board: ccc-hints
+| role | agent | status | item | files |
+|---|---|---|---|---|
+| dev |  | doing | C1 hint.rs + C4 completions.rs + mod 8sync-hints (lead) |  |
+| qa |  | rest | chạy sau khi mod có test (C3/C6) |  |
+| review |  | rest | review diff ở bước D |  |
diff --git a/su-code/ship/ccc-hints/STANDUP.md b/su-code/ship/ccc-hints/STANDUP.md
new file mode 100644
index 00000000..65d5cd0e
--- /dev/null
+++ b/su-code/ship/ccc-hints/STANDUP.md
@@ -0,0 +1,2 @@
+# Standups: ccc-hints
+1 · 2026-10-16T01:30Z · done 0 · doing 0 · blocked 0 · idle dev,review,qa
diff --git a/su-code/ship/ccc-hints/loop.json b/su-code/ship/ccc-hints/loop.json
new file mode 100644
index 00000000..f62d026f
--- /dev/null
+++ b/su-code/ship/ccc-hints/loop.json
@@ -0,0 +1,11 @@
+{
+  "digests": [
+    "6730cfc5ce80541f C2:mod-missing"
+  ],
+  "iter": 1,
+  "max_iter": 12,
+  "max_min": 90,
+  "slug": "ccc-hints",
+  "started": 1792113750,
+  "stopped": null
+}