feat(kiro): agent status, session history and usage fixes (builds on #14001)

config/tsconfig.cli.json

@@ -259,6 +259,8 @@
     "../src/main/jcode/hook-service.ts",
     "../src/main/kimi/hook-service.ts",
     "../src/main/kimi/kimi-hook-config-toml.ts",
+    "../src/main/kiro/hook-service.ts",
+    "../src/main/kiro/hook-settings.ts",
     "../src/main/dsh/dsh-home-patch.ts",
     "../src/main/dsh/hook-service.ts",
     "../src/main/dsh/hook-settings.ts",

src/main/agent-hooks/installer-utils-remote.ts

@@ -135,6 +135,21 @@ export async function readTextFileRemote(
   }
 }
 
+/** Entry names in a remote directory, or null when the directory does not exist. */
+export async function listRemoteDirectory(
+  sftp: SFTPWrapper,
+  remotePath: string
+): Promise<string[] | null> {
+  try {
+    return (await readdir(sftp, remotePath)).map((entry) => entry.filename)
+  } catch (err) {
+    if (isNoEntryError(err)) {
+      return null
+    }
+    throw err
+  }
+}
+
 export async function writeTextFileRemoteAtomic(
   sftp: SFTPWrapper,
   remotePath: string,

src/main/agent-hooks/managed-agent-hook-registry.ts

@@ -18,6 +18,7 @@ import { grokHookService } from '../grok/hook-service'
 import { hermesHookService } from '../hermes/hook-service'
 import { jcodeHookService } from '../jcode/hook-service'
 import { kimiHookService } from '../kimi/hook-service'
+import { kiroHookService } from '../kiro/hook-service'
 import { museHookService } from '../muse/hook-service'
 import { openClaudeHookService } from '../openclaude/hook-service'
 import { zcodeHookService } from '../zcode/hook-service'
@@ -65,7 +66,8 @@ export const MANAGED_AGENT_HOOK_INSTALLERS: readonly ManagedAgentHookInstaller[]
   ['muse', () => museHookService.install()],
   ['zcode', () => zcodeHookService.install()],
   ['dsh', () => dshHookService.install()],
-  ['jcode', () => jcodeHookService.install()]
+  ['jcode', () => jcodeHookService.install()],
+  ['kiro', () => kiroHookService.install()]
 ]
 
 // Why: covers the shared launcher/statusline scripts under ~/.orca/agent-hooks — the files a
@@ -94,7 +96,8 @@ export const MANAGED_AGENT_HOOK_SCRIPT_REFRESHERS: readonly ManagedAgentHookScri
   ['muse', () => museHookService.refreshManagedScripts()],
   ['zcode', () => zcodeHookService.refreshManagedScripts()],
   ['dsh', () => dshHookService.refreshManagedScripts()],
-  ['jcode', () => jcodeHookService.refreshManagedScripts()]
+  ['jcode', () => jcodeHookService.refreshManagedScripts()],
+  ['kiro', () => kiroHookService.refreshManagedScripts()]
 ]
 
 export const MANAGED_AGENT_HOOK_REMOVERS: readonly ManagedAgentHookRemover[] = [
@@ -119,7 +122,8 @@ export const MANAGED_AGENT_HOOK_REMOVERS: readonly ManagedAgentHookRemover[] = [
   ['muse', () => museHookService.remove()],
   ['zcode', () => zcodeHookService.remove()],
   ['dsh', () => dshHookService.remove()],
-  ['jcode', () => jcodeHookService.remove()]
+  ['jcode', () => jcodeHookService.remove()],
+  ['kiro', () => kiroHookService.remove()]
 ]
 
 export const MANAGED_AGENT_HOOK_ASYNC_REMOVERS: readonly ManagedAgentHookAsyncRemover[] = [
@@ -148,5 +152,6 @@ export const MANAGED_AGENT_HOOK_STATUS_READERS: readonly ManagedAgentHookStatusR
   ['muse', () => museHookService.getStatus()],
   ['zcode', () => zcodeHookService.getStatus()],
   ['dsh', () => dshHookService.getStatus()],
-  ['jcode', () => jcodeHookService.getStatus()]
+  ['jcode', () => jcodeHookService.getStatus()],
+  ['kiro', () => kiroHookService.getStatus()]
 ]

src/main/agent-hooks/managed-hook-command-contract.test.ts

@@ -25,6 +25,7 @@ import { getMuseManagedCommand, getMuseRemoteManagedCommand } from '../muse/hook
 import { getDshManagedCommand, getDshRemoteManagedCommand } from '../dsh/hook-settings'
 import { getZCodeManagedCommand, getZCodeRemoteManagedCommand } from '../zcode/hook-settings'
 import { getJcodeManagedCommand, getJcodeRemoteManagedCommand } from '../jcode/hook-settings'
+import { getKiroManagedCommand, getKiroRemoteManagedCommand } from '../kiro/hook-settings'
 import {
   wrapPosixHookCommand,
   wrapWindowsCmdHookCommand,
@@ -227,6 +228,13 @@ const buildersByAgent = new Map<string, CommandBuilders>([
       local: (path) => [getJcodeManagedCommand(path)],
       remote: (path) => [getJcodeRemoteManagedCommand(path)]
     }
+  ],
+  [
+    'kiro',
+    {
+      local: (path) => [getKiroManagedCommand(path)],
+      remote: (path) => [getKiroRemoteManagedCommand(path)]
+    }
   ]
 ])
 

src/main/agent-hooks/managed-hook-local-filesystem.ts

@@ -36,10 +36,16 @@ export function createManagedHookLocalFilesystem(): SFTPWrapper {
     stat(path: string, callback: Callback<{ mode: number }>): void {
       stat(path, (error, stats) => finish(callback, error, stats))
     },
-    readdir(path: string, callback: Callback<[]>): void {
-      // Why: installers use readdir only as an existence check; names and
-      // attrs would allocate work that no caller consumes.
-      readdir(path, (error) => finish(callback, error, []))
+    readdir(path: string, callback: Callback<{ filename: string }[]>): void {
+      // Why names only: Kiro lists its agent configs by name; attrs have no consumer,
+      // matching the WSL adapter's `{ filename }` entries.
+      readdir(path, (error, names) =>
+        finish(
+          callback,
+          error,
+          names?.map((filename) => ({ filename }))
+        )
+      )
     },
     mkdir(path: string, callback: Callback): void {
       mkdir(path, (error) => finish(callback, error))

src/main/agent-hooks/managed-hook-runtime.test.ts

@@ -17,7 +17,8 @@ const { execFile } = await import('node:child_process')
 const execFileMock = vi.mocked(execFile)
 const { execFile: actualExecFile } =
   await vi.importActual<typeof NodeChildProcess>('node:child_process')
-const { installManagedHooks, resolveRelayGrokHome } = await import('./managed-hook-runtime')
+const { installManagedHooks, resolveRelayGrokHome, resolveRelayKiroHome } =
+  await import('./managed-hook-runtime')
 
 type ExecFileCallback = (error: Error | null, result?: { stdout: string; stderr: string }) => void
 
@@ -120,6 +121,25 @@ describe.runIf(process.platform !== 'win32')('resolveRelayGrokHome', () => {
   })
 })
 
+describe.runIf(process.platform !== 'win32')('resolveRelayKiroHome', () => {
+  it('reads KIRO_HOME from the login shell', async () => {
+    vi.stubEnv('SHELL', '/bin/sh')
+    stubProbeOutput('/srv/kiro/\n')
+
+    await expect(resolveRelayKiroHome('/home/orca')).resolves.toBe('/srv/kiro')
+    expect(execFileMock.mock.calls[0]?.[1]?.[1]).toContain('printenv KIRO_HOME')
+  })
+
+  it('falls back to ~/.kiro when KIRO_HOME is unset or the probe fails', async () => {
+    vi.stubEnv('SHELL', '/bin/sh')
+    stubProbeOutput('\n')
+    await expect(resolveRelayKiroHome('/home/orca')).resolves.toBe('/home/orca/.kiro')
+
+    stubProbeFailure(new Error('spawn failed'))
+    await expect(resolveRelayKiroHome('/home/orca')).resolves.toBe('/home/orca/.kiro')
+  })
+})
+
 describe.runIf(process.platform !== 'win32')('installManagedHooks', () => {
   it.each([
     ['omitted', undefined],

src/main/agent-hooks/managed-hook-runtime.ts

@@ -12,16 +12,16 @@ import {
 } from './managed-hook-owner-identity'
 
 const execFileAsync = promisify(execFile)
-const GROK_HOME_MAX_LENGTH = 4096
-const GROK_HOME_PROBE_TIMEOUT_MS = 8_000
+const AGENT_HOME_MAX_LENGTH = 4096
+const AGENT_HOME_PROBE_TIMEOUT_MS = 8_000
 
 export type ManagedHookInstallSummary = {
   installers: number
   errors: number
 }
 
-function defaultGrokHome(home: string): string {
-  return `${home.replace(/\/+$/, '') || home}/.grok`
+function defaultAgentHome(home: string, dirName: string): string {
+  return `${home.replace(/\/+$/, '') || home}/${dirName}`
 }
 
 function hasControlCharacter(value: string): boolean {
@@ -31,10 +31,10 @@ function hasControlCharacter(value: string): boolean {
   })
 }
 
-function normalizeGrokHome(candidate: string): string | null {
+function normalizeAgentHome(candidate: string): string | null {
   if (
     candidate.length === 0 ||
-    candidate.length > GROK_HOME_MAX_LENGTH ||
+    candidate.length > AGENT_HOME_MAX_LENGTH ||
     candidate !== candidate.trim() ||
     !candidate.startsWith('/') ||
     candidate.includes('\\') ||
@@ -53,26 +53,38 @@ function resolveLoginShell(): string {
   return candidate
 }
 
-export async function resolveRelayGrokHome(home: string, signal?: AbortSignal): Promise<string> {
-  const fallback = defaultGrokHome(home)
+async function resolveRelayAgentHome(
+  envName: 'GROK_HOME' | 'KIRO_HOME',
+  fallback: string,
+  signal?: AbortSignal
+): Promise<string> {
   try {
     const shell = resolveLoginShell()
     const shellName = basename(shell)
     const mode = shellName === 'sh' || shellName === 'dash' ? '-c' : '-lc'
     // Why: agent PTYs start login shells, so read the same profile-derived
-    // GROK_HOME without opening two additional SSH exec channels.
+    // home override without opening two additional SSH exec channels.
     const { stdout } = await execFileAsync(
       shell,
-      [mode, `printenv GROK_HOME | head -c ${GROK_HOME_MAX_LENGTH + 1}`],
-      { encoding: 'utf8', timeout: GROK_HOME_PROBE_TIMEOUT_MS, signal }
+      [mode, `printenv ${envName} | head -c ${AGENT_HOME_MAX_LENGTH + 1}`],
+      { encoding: 'utf8', timeout: AGENT_HOME_PROBE_TIMEOUT_MS, signal }
     )
-    return normalizeGrokHome(stdout.split(/\r?\n/, 1)[0] ?? '') ?? fallback
+    return normalizeAgentHome(stdout.split(/\r?\n/, 1)[0] ?? '') ?? fallback
   } catch {
     signal?.throwIfAborted()
     return fallback
   }
 }
 
+export function resolveRelayGrokHome(home: string, signal?: AbortSignal): Promise<string> {
+  return resolveRelayAgentHome('GROK_HOME', defaultAgentHome(home, '.grok'), signal)
+}
+
+/** `$KIRO_HOME` replaces `~/.kiro` outright, for agent configs and sessions alike. */
+export function resolveRelayKiroHome(home: string, signal?: AbortSignal): Promise<string> {
+  return resolveRelayAgentHome('KIRO_HOME', defaultAgentHome(home, '.kiro'), signal)
+}
+
 export async function installManagedHooks(options?: {
   signal?: AbortSignal
   hostKeyFingerprint?: string
@@ -86,9 +98,11 @@ export async function installManagedHooks(options?: {
     return { installers: 0, errors: 0 }
   }
   const home = homedir()
-  const grokHomeDir = agents.includes('grok')
-    ? await resolveRelayGrokHome(home, options?.signal)
-    : undefined
+  // Why parallel: each probe may wait out its own login-shell timeout.
+  const [grokHomeDir, kiroHomeDir] = await Promise.all([
+    agents.includes('grok') ? resolveRelayGrokHome(home, options?.signal) : undefined,
+    agents.includes('kiro') ? resolveRelayKiroHome(home, options?.signal) : undefined
+  ])
   options?.signal?.throwIfAborted()
   const hostIdentity = scopeManagedHookHostIdentity(
     await readManagedHookHostIdentity(),
@@ -103,6 +117,7 @@ export async function installManagedHooks(options?: {
         home,
         {
           grokHomeDir,
+          kiroHomeDir,
           signal: options?.signal,
           agents,
           ...(options?.claudeVersion ? { claudeVersion: options.claudeVersion } : {})

src/main/agent-hooks/remote-hook-service-registry-coverage.test.ts

@@ -21,6 +21,7 @@ import { grokHookService } from '../grok/hook-service'
 import { hermesHookService } from '../hermes/hook-service'
 import { kimiHookService } from '../kimi/hook-service'
 import { dshHookService } from '../dsh/hook-service'
+import { kiroHookService } from '../kiro/hook-service'
 import { museHookService } from '../muse/hook-service'
 import { openClaudeHookService } from '../openclaude/hook-service'
 import { qwenCodeHookService } from '../qwen-code/hook-service'
@@ -61,6 +62,7 @@ describe('remote hook service registry coverage', () => {
       ['codebuddy', codebuddyHookService],
       ['zcode', zcodeHookService],
       ['dsh', dshHookService],
+      ['kiro', kiroHookService],
       ['jcode', jcodeHookService]
     ])
 

src/main/agent-hooks/remote-managed-hook-installers.ts

@@ -17,6 +17,7 @@ import { grokHookService } from '../grok/hook-service'
 import { hermesHookService } from '../hermes/hook-service'
 import { jcodeHookService } from '../jcode/hook-service'
 import { kimiHookService } from '../kimi/hook-service'
+import { kiroHookService } from '../kiro/hook-service'
 import { dshHookService } from '../dsh/hook-service'
 import { museHookService } from '../muse/hook-service'
 import { zcodeHookService } from '../zcode/hook-service'
@@ -29,6 +30,8 @@ export type RemoteManagedHookInstallOptions = {
   deferTrustUntilConfigToml?: boolean
   /** Explicit GROK_HOME for remote runtimes that redirect Grok's config. */
   grokHomeDir?: string
+  /** Login-shell KIRO_HOME on the execution host; it replaces ~/.kiro outright. */
+  kiroHomeDir?: string
   /** Version reported by Claude on this execution host. */
   claudeVersion?: string
   /** Stops before starting the next installer when the owning relay request
@@ -87,7 +90,12 @@ const REMOTE_MANAGED_HOOK_INSTALLERS: readonly RemoteManagedHookInstaller[] = [
   ['muse', (sftp, remoteHome) => museHookService.installRemote(sftp, remoteHome)],
   ['zcode', (sftp, remoteHome) => zcodeHookService.installRemote(sftp, remoteHome)],
   ['dsh', (sftp, remoteHome) => dshHookService.installRemote(sftp, remoteHome)],
-  ['jcode', (sftp, remoteHome) => jcodeHookService.installRemote(sftp, remoteHome)]
+  ['jcode', (sftp, remoteHome) => jcodeHookService.installRemote(sftp, remoteHome)],
+  [
+    'kiro',
+    (sftp, remoteHome, options) =>
+      kiroHookService.installRemote(sftp, remoteHome, options?.kiroHomeDir)
+  ]
 ]
 
 /** Agents wired into the remote (SSH) hook installer. Exported so an invariant

src/main/agent-hooks/server-retired-pane-new-turn.test.ts

@@ -48,7 +48,8 @@ const NEW_TURN_EVENT: Record<AgentHookSource, string | null> = {
   muse: 'UserPromptSubmit',
   zcode: 'SessionStart',
   dsh: 'SessionStart',
-  jcode: 'turn_start'
+  jcode: 'turn_start',
+  kiro: 'agentSpawn'
 }
 
 function reviveRetiredPane(source: unknown, hookEventName: string): boolean {

src/main/ai-vault/remote-session-scanner-kiro-source.ts

@@ -0,0 +1,70 @@
+import type { RemoteHostPlatform } from '../ssh/ssh-remote-platform'
+import { joinRemotePath } from '../ssh/ssh-remote-platform'
+import { throwIfAiVaultScanCancelled } from './ai-vault-scan-cancellation'
+import { isMissingRemoteSessionPathError } from './remote-session-file-stat'
+import {
+  remoteSessionContentLines,
+  streamedSessionContentLines
+} from './remote-session-content-lines'
+import type { RemoteScannerContext, RemoteSessionSource } from './remote-session-scanner-types'
+import {
+  isKiroSessionMetadataPath,
+  kiroTranscriptPathForMetadata,
+  parseKiroSessionContent
+} from './session-scanner-kiro-parser'
+
+async function readTranscriptLines(
+  metadataPath: string,
+  context: RemoteScannerContext
+): Promise<Iterable<string> | AsyncIterable<string> | null> {
+  const transcriptPath = kiroTranscriptPathForMetadata(metadataPath)
+  // Why: beside the execution host the transcript streams; megabyte tool outputs are common.
+  if (context.provider.readTranscriptBytes) {
+    return streamedSessionContentLines(
+      context.provider.readTranscriptBytes(transcriptPath, context.signal),
+      context.signal
+    )
+  }
+  try {
+    throwIfAiVaultScanCancelled(context.signal)
+    const read = await context.provider.readFile(transcriptPath)
+    throwIfAiVaultScanCancelled(context.signal)
+    return read.isBinary ? null : remoteSessionContentLines(read.content, context.signal)
+  } catch (error) {
+    throwIfAiVaultScanCancelled(context.signal)
+    if (isMissingRemoteSessionPathError(error)) {
+      return null
+    }
+    throw error
+  }
+}
+
+export function remoteKiroSource(
+  remoteHome: string,
+  hostPlatform: RemoteHostPlatform
+): RemoteSessionSource {
+  return {
+    agent: 'kiro',
+    rootDir: joinRemotePath(hostPlatform, remoteHome, '.kiro', 'sessions', 'cli'),
+    extensions: ['.json'],
+    filePredicate: isKiroSessionMetadataPath,
+    contentDependencyPath: kiroTranscriptPathForMetadata,
+    directoryPredicate: () => false,
+    parse: async (file, content, context) => {
+      const options = {
+        executionHostId: context.executionHostId,
+        executionHostPlatform: context.hostPlatform.os
+      }
+      try {
+        const lines = await readTranscriptLines(file.path, context)
+        return await parseKiroSessionContent(file, content, lines, context.hostPlatform.os, options)
+      } catch (error) {
+        // A transcript that vanished mid-stream leaves a valid metadata-only session.
+        if (!isMissingRemoteSessionPathError(error)) {
+          throw error
+        }
+        return parseKiroSessionContent(file, content, null, context.hostPlatform.os, options)
+      }
+    }
+  }
+}