refactor: apply repository naming contract

Apply the accepted pre-release package, service, type, directory, and role renames as one repository-wide change.

packages/core/agent-loop/src/agent.ts

@@ -139,7 +139,7 @@ export class ReactLoopAgent implements Agent {
     if (this.phase.kind !== 'idle') this.phase.abort.abort(cause)
   }
 
-  runMaintenance<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T> {
+  runMaintenance<T>(job: (signal: AbortSignal) => Promise<T>): Promise<T> {
     if (this.phase.kind !== 'idle') throw new Error(`agent "${this.id}" already has active work`)
     const done = Promise.withResolvers<void>()
     const maintenance: Phase = {
@@ -152,7 +152,7 @@ export class ReactLoopAgent implements Agent {
     this.activityDone = done.promise
     return (async () => {
       try {
-        return await task(maintenance.abort.signal)
+        return await job(maintenance.abort.signal)
       } finally {
         this.setPhase({ kind: 'idle', lastTurn: maintenance.lastTurn })
         if (maintenance.wakeRequested && this.inbox.hasPending) this.wakeDriver()

packages/core/agent-loop/src/index.ts

@@ -62,20 +62,20 @@ class FactoryOwnership {
   }
 
   /** Join config startup work that begins before an agent exists. */
-  trackStartup(task: Promise<void>): void {
-    this.startupTasks.add(task)
-    const forget = () => { this.startupTasks.delete(task) }
-    void task.then(forget, forget)
+  trackStartup(job: Promise<void>): void {
+    this.startupTasks.add(job)
+    const forget = () => { this.startupTasks.delete(job) }
+    void job.then(forget, forget)
   }
 
   /** Join one public create/resume continuation; factory dispose awaits its settlement. */
-  trackWrapper(task: Promise<unknown>): void {
-    this.trackStartup(task.then(() => undefined, () => undefined))
+  trackWrapper(job: Promise<unknown>): void {
+    this.trackStartup(job.then(() => undefined, () => undefined))
   }
 
   /** Resolve `task`, or stop waiting when factory teardown begins. */
-  async waitWhileActive(task: Promise<void>): Promise<void> {
-    await Promise.race([task, this.inactive.promise])
+  async waitWhileActive(job: Promise<void>): Promise<void> {
+    await Promise.race([job, this.inactive.promise])
   }
 
   async dispose(): Promise<void> {

packages/core/agent-loop/src/tool-calls.ts

@@ -14,7 +14,7 @@
 import type { Context } from '@deepseek-ai/cordis'
 import { assertNever, createToolResultMessage, type ToolCallBlock } from '@deepseek-ai/dsh-llm'
 import type { Session, UserMessage } from '@deepseek-ai/dsh-session'
-import { TOOL_ABORTED_BEFORE_DISPATCH, TOOL_REGISTRY_SCHEDULER, type ToolExecutionInput, type ToolExecutionMode, type ToolExecutionResult, type ToolRunContext } from '@deepseek-ai/dsh-tools'
+import { TOOL_ABORTED_BEFORE_DISPATCH, TOOL_RUNTIME_SCHEDULER, type ToolExecutionInput, type ToolExecutionMode, type ToolExecutionResult, type ToolRunContext } from '@deepseek-ai/dsh-tools'
 
 /** One tool call after argument parsing, ready to schedule. */
 interface PlannedCall {
@@ -149,8 +149,8 @@ async function runGroup(
       if (slot === undefined) break
       const call = group[committed]
       const result = slot.needsPost
-        ? await ctx.tools[TOOL_REGISTRY_SCHEDULER].finalize(slot.exec, slot.result)
-        : ctx.tools[TOOL_REGISTRY_SCHEDULER].finish(slot.exec, slot.result)
+        ? await ctx.tools[TOOL_RUNTIME_SCHEDULER].finalize(slot.exec, slot.result)
+        : ctx.tools[TOOL_RUNTIME_SCHEDULER].finish(slot.exec, slot.result)
       // oxlint-disable-next-line typescript/no-non-null-assertion -- bounded index
       appendToolResult(session, turn, step, call!.block, result, callSeqs[committed]!)
       for (const context of result.additionalContexts ?? []) acceptContext(context)
@@ -166,11 +166,11 @@ async function runGroup(
     const call = group[index]!
     callSeqs[index] = appendToolCall(session, turn, step, call.block)
     started++
-    const prepared = await ctx.tools[TOOL_REGISTRY_SCHEDULER].prepare(call.exec)
+    const prepared = await ctx.tools[TOOL_RUNTIME_SCHEDULER].prepare(call.exec)
     throwSchedulerFailure()
     switch (prepared.kind) {
       case 'dispatch': {
-        const promise = ctx.tools[TOOL_REGISTRY_SCHEDULER].dispatch(prepared.exec).then(
+        const promise = ctx.tools[TOOL_RUNTIME_SCHEDULER].dispatch(prepared.exec).then(
           (outcome) => {
             slots[index] = { exec: prepared.exec, result: outcome.result, needsPost: outcome.kind === 'post-result' }
             return index