Merge pull request #3073 from deepseek-harness/worktree-apire-a

refactor(apiproxy): delete the goal unary domain

packages/api/session-controller/tests/fake-api.client.ts

@@ -256,15 +256,6 @@ export class FakeApiClient implements IApiClient {
     list: (payload: unknown) => this.record('skill.list', payload, this.onSkillList(payload)),
   }
 
-  readonly goals: IApiClient['goals'] = {
-    create: payload => this.record('goal.create', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    edit: payload => this.record('goal.edit', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    pause: payload => this.record('goal.pause', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    resume: payload => this.record('goal.resume', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    complete: payload => this.record('goal.complete', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    clear: payload => this.record('goal.clear', payload, Promise.resolve(ok({ cleared: true as const }))),
-  }
-
   readonly settings: IApiClient['settings'] = {
     describe: payload => this.record('settings.describe', payload, Promise.resolve(ok({ writable: true, hasDocument: false, namespaces: [] }))),
     openDocument: payload => this.record('settings.openDocument', payload, Promise.resolve(ok({ opened: true as const }))),

packages/client/connection/src/client/api.ts

@@ -12,7 +12,6 @@ export type {
   SkillsApi, SkillEntry,
   ModelCatalog, ModelCatalogFailure, ModelCatalogModel, ModelProviderGroup, ModelReasoning,
   ModelReasoningEffort, ModelSelection,
-  GoalsApi, GoalRef,
   SettingsApi, SettingsNamespaceView, SettingsPathOpView, SettingsSecretView,
   CredentialsApi, CredentialView, ConfigurableProviderView, DiscoveredModelView, LlmApi,
   SubagentsApi, SubagentAddress, SubagentCatalog, SubagentListEntry, SubagentPromptReceipt,

packages/client/connection/src/client/fixture.ts

@@ -2273,18 +2273,6 @@ function createFixtureWorld(options: FixtureOptions): FixtureWorld {
     return { ok: true, value: goalView(projection) }
   }
 
-  const mapGoalResult = <T, U>(result: RpcResult<T>, map: (value: T) => U): RpcResult<U> => (
-    result.ok ? { ok: true, value: map(result.value) } : result
-  )
-
-  const goalRefResult = (result: RpcResult<FxGoalView>): RpcResult<{ ref: { id: never; revision: number } }> => (
-    mapGoalResult(result, view => ({ ref: { id: view.id as never, revision: view.revision } }))
-  )
-
-  const legacyGoalResponse = <P, T>(request: RpcRequest<P>, result: RpcResult<T>): Promise<RpcResponse<T>> => (
-    Promise.resolve({ rpcId: request.rpcId, result })
-  )
-
   /** At most one in-flight replay per session; cancel clears it. */
   const replays = new Map<SessionId, { timer: ReturnType<typeof setTimeout>; finish(aborted: boolean): void }>()
 
@@ -3339,46 +3327,6 @@ function createFixtureWorld(options: FixtureOptions): FixtureWorld {
         })
       },
     },
-    goals: {
-      // Compatibility face only: old API Proxy payloads and acknowledgements
-      // adapt to the canonical fixture Remote implementation above.
-      create: request => legacyGoalResponse(
-        request,
-        mapGoalResult(
-          goalRemotes.create(request.payload.sessionId, {
-            objective: request.payload.objective,
-            ...request.payload.maxGoalRounds === undefined ? {} : { maxGoalRounds: request.payload.maxGoalRounds },
-          }),
-          value => ({ ref: { id: value.ref.id as never, revision: value.ref.revision } }),
-        ),
-      ),
-      edit: request => legacyGoalResponse(
-        request,
-        goalRefResult(goalRemotes.edit(request.payload.sessionId, request.payload.ref, {
-          ...request.payload.objective === undefined ? {} : { objective: request.payload.objective },
-          ...request.payload.maxGoalRounds === undefined ? {} : { maxGoalRounds: request.payload.maxGoalRounds },
-        })),
-      ),
-      pause: request => legacyGoalResponse(
-        request,
-        goalRefResult(goalRemotes.pause(request.payload.sessionId, request.payload.ref)),
-      ),
-      resume: request => legacyGoalResponse(
-        request,
-        goalRefResult(goalRemotes.resume(request.payload.sessionId, request.payload.ref)),
-      ),
-      complete: request => legacyGoalResponse(
-        request,
-        goalRefResult(goalRemotes.complete(request.payload.sessionId, request.payload.ref)),
-      ),
-      clear: request => legacyGoalResponse(
-        request,
-        mapGoalResult(
-          goalRemotes.clear(request.payload.sessionId, request.payload.ref),
-          () => ({ cleared: true as const }),
-        ),
-      ),
-    },
     settings: {
       // Only the resolved DeepSeek address needed by first-run readiness is
       // represented here. Fixture-backed journeys do not open its Models
@@ -3638,12 +3586,6 @@ export class FixtureApiClient extends AbstractApiClient {
       case 'agentPreset.copy': return this.api.agentPresets.copy(request)
       case 'agentPreset.openDocument': return this.api.agentPresets.openDocument(request, new AbortController().signal)
       case 'agentPreset.remove': return this.api.agentPresets.remove(request)
-      case 'goal.create': return this.api.goals.create(request)
-      case 'goal.edit': return this.api.goals.edit(request)
-      case 'goal.pause': return this.api.goals.pause(request)
-      case 'goal.resume': return this.api.goals.resume(request)
-      case 'goal.complete': return this.api.goals.complete(request)
-      case 'goal.clear': return this.api.goals.clear(request)
       case 'settings.describe': return this.api.settings.describe(request)
       case 'settings.openDocument': return this.api.settings.openDocument(request, signal)
       case 'settings.update': return this.api.settings.update(request)

packages/client/connection/src/client/index.ts

@@ -39,7 +39,6 @@ export type {
   RpcRequest, RpcResponse, RpcResult, RpcError, RpcErrorCode,
   ClientRequest, ServerResponse, RpcMessage,
   HostDescription, IApiClient, SessionId, SessionEvent, ContentBlock, StreamChunk,
-  GoalsApi, GoalRef,
   SettingsApi, SettingsNamespaceView, SettingsPathOpView, SettingsSecretView,
   CredentialsApi, CredentialView, ConfigurableProviderView, DiscoveredModelView, LlmApi,
 } from './api.ts'

packages/client/connection/tests/fake-api.client.ts

@@ -116,15 +116,6 @@ export class FakeApiClient implements IApiClient {
     list: (payload: unknown) => this.record('skill.list', payload, this.onSkillList(payload)),
   }
 
-  readonly goals: IApiClient['goals'] = {
-    create: payload => this.record('goal.create', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    edit: payload => this.record('goal.edit', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    pause: payload => this.record('goal.pause', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    resume: payload => this.record('goal.resume', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    complete: payload => this.record('goal.complete', payload, Promise.resolve(ok({ ref: { id: 'fake-goal' as never, revision: 1 } }))),
-    clear: payload => this.record('goal.clear', payload, Promise.resolve(ok({ cleared: true as const }))),
-  }
-
   readonly settings: IApiClient['settings'] = {
     describe: payload => this.record('settings.describe', payload, Promise.resolve(ok({ writable: true, hasDocument: false, namespaces: [] }))),
     openDocument: payload => this.record('settings.openDocument', payload, Promise.resolve(ok({ opened: true as const }))),

packages/client/connection/tests/fixture.client.spec.ts

@@ -1603,29 +1603,33 @@ describe('FixtureApiClient (protocol-level fake carrier)', () => {
     const moved = await workspaces.insertSessionBefore({ workspaceId: wsid, sessionId: attached.result.value.sessionId })
     if (!moved.result.ok) throw new Error('workspace move failed')
     expect(moved.result.value.workspace.sessionIds).toEqual([attached.result.value.sessionId])
-    // Goal lifecycle over the fixture fold: create → edit → pause → resume → complete → clear;
-    // every mutation acknowledges with the NEW CAS ref (state rides the projection frames).
-    const goalCreated = await client.goals.create({ sessionId: id, objective: 'ship it' })
-    if (!goalCreated.result.ok) throw new Error('goal create failed')
-    let ref = goalCreated.result.value.ref
-    expect(ref.revision).toBe(1)
-    const edited = await client.goals.edit({ sessionId: id, ref, objective: 'ship it v2' })
-    if (!edited.result.ok) throw new Error('goal edit failed')
-    ref = edited.result.value.ref
-    const paused = await client.goals.pause({ sessionId: id, ref })
-    if (!paused.result.ok) throw new Error('goal pause failed')
-    ref = paused.result.value.ref
-    const resumed = await client.goals.resume({ sessionId: id, ref })
-    if (!resumed.result.ok) throw new Error('goal resume failed')
-    ref = resumed.result.value.ref
+  })
+
+  it('folds the goal lifecycle over the Goal Remotes', async () => {
+    const client = new FixtureApiClient()
+    const sessions = createSessionClient(client.rpc)
+    const created = await sessions.create({})
+    if (!created.result.ok) throw new Error('create failed')
+    const id = created.result.value.sessionId
+    const goal = (endpoint: string, args: Record<string, unknown>) =>
+      client.rpc.call('/api', endpoint, { args: { agentId: id, ...args } })
+
+    // create → edit → pause → resume → complete → clear; each mutation advances the CAS
+    // revision by one (state rides the projection frames).
+    const goalCreated = await goal('goals/create', { request: { objective: 'ship it' } })
+    if (!goalCreated.ok) throw new Error('goal create failed')
+    const { id: goalId, revision } = (goalCreated.value as { ref: { id: string; revision: number } }).ref
+    expect(revision).toBe(1)
+    const ref = (at: number) => ({ id: goalId, revision: at })
+    expect((await goal('goals/edit', { ref: ref(1), request: { objective: 'ship it v2' } })).ok).toBe(true)
+    expect((await goal('goals/pause', { ref: ref(2) })).ok).toBe(true)
+    expect((await goal('goals/resume', { ref: ref(3) })).ok).toBe(true)
     // A stale ref loses the CAS check.
-    expect((await client.goals.pause({ sessionId: id, ref: { ...ref, revision: 1 } })).result.ok).toBe(false)
-    const completed = await client.goals.complete({ sessionId: id, ref })
-    if (!completed.result.ok) throw new Error('goal complete failed')
-    ref = completed.result.value.ref
+    expect((await goal('goals/pause', { ref: ref(1) })).ok).toBe(false)
+    expect((await goal('goals/complete', { ref: ref(4) })).ok).toBe(true)
     // complete → complete is an invalid transition.
-    expect((await client.goals.complete({ sessionId: id, ref })).result.ok).toBe(false)
-    expect((await client.goals.clear({ sessionId: id, ref })).result).toEqual({ ok: true, value: { cleared: true } })
+    expect((await goal('goals/complete', { ref: ref(5) })).ok).toBe(false)
+    expect(await goal('goals/clear', { ref: ref(5) })).toEqual({ ok: true, value: ref(6) })
 
     const goalHistory = await sessions.history({ sessionId: id })
     if (!goalHistory.result.ok) throw new Error('goal history failed')

packages/client/ui-workspace/tests/workspaces-service.client.spec.ts

@@ -188,7 +188,6 @@ class FakeApiClient implements IApiClient {
   declare readonly subagents: IApiClient['subagents']
   declare readonly skills: IApiClient['skills']
   declare readonly agentPresets: IApiClient['agentPresets']
-  declare readonly goals: IApiClient['goals']
   declare readonly settings: IApiClient['settings']
   declare readonly credentials: IApiClient['credentials']
   declare readonly llm: IApiClient['llm']

packages/extensions/tool-cordis/src/api-catalog.ts

@@ -3767,6 +3767,10 @@ export const TYPE_API: readonly TypeApiEntry[] = [
     name: 'GoalChanged',
     declaration: 'export interface GoalChanged {\n    readonly operation: GoalOperation;\n    readonly ref: GoalRef;\n    readonly goal?: GoalView;\n}',
   },
+  {
+    name: 'GoalId',
+    declaration: 'export type GoalId = Branded<\'GoalId\'>;',
+  },
   {
     name: 'GoalOperation',
     declaration: 'export type GoalOperation = \'create\' | \'edit\' | \'pause\' | \'resume\' | \'complete\' | \'block\' | \'clear\';',
@@ -3775,6 +3779,10 @@ export const TYPE_API: readonly TypeApiEntry[] = [
     name: 'GoalPhase',
     declaration: 'export type GoalPhase = \'active\' | \'paused\' | \'blocked\' | \'complete\';',
   },
+  {
+    name: 'GoalRef',
+    declaration: 'export interface GoalRef {\n    readonly id: GoalId;\n    readonly revision: number;\n}',
+  },
   {
     name: 'GoalSnapshot',
     declaration: 'export interface GoalSnapshot extends GoalRef {\n    readonly objective: string;\n    readonly phase: GoalPhase;\n    readonly blockedReason?: GoalBlockReason;\n    readonly maxGoalRounds: number;\n}',

packages/host/apiproxy/package.json

@@ -52,7 +52,6 @@
     "@deepseek-ai/dsh-brand": "workspace:^",
     "@deepseek-ai/dsh-commands": "workspace:^",
     "@deepseek-ai/dsh-credentials": "workspace:^",
-    "@deepseek-ai/dsh-goal": "workspace:^",
     "@deepseek-ai/dsh-host-directory-picker": "workspace:^",
     "@deepseek-ai/dsh-llm": "workspace:^",
     "@deepseek-ai/dsh-native-command": "workspace:^",

packages/host/apiproxy/src/api-proxy.ts

@@ -6,7 +6,7 @@
 import { homedir } from 'node:os'
 import { dirname } from 'node:path'
 import type { Context } from '@deepseek-ai/cordis'
-import type { Agent, ModelSelection } from '@deepseek-ai/dsh-agent'
+import type { ModelSelection } from '@deepseek-ai/dsh-agent'
 import type {} from '@deepseek-ai/dsh-agent-presets/types'
 import type { Session, SessionId } from '@deepseek-ai/dsh-session'
 import { SubagentError } from '@deepseek-ai/dsh-subagent'
@@ -16,7 +16,7 @@ import {
   PresetNotWritableError, UnknownPresetError,
 } from '@deepseek-ai/dsh-agent-presets'
 import type {
-  ApiProxy, ConfigurableProviderView, CredentialView, GoalRef,
+  ApiProxy, ConfigurableProviderView, CredentialView,
   SettingsNamespaceView,
 } from './api/index.ts'
 import type { SessionRequestId } from '@deepseek-ai/dsh-api-session-controller/types'
@@ -32,9 +32,6 @@ import {
   type SessionLogCompressionLevel,
 } from './session-export.ts'
 import type { SessionRawArtifact } from '@deepseek-ai/dsh-session-persistence'
-// GoalError narrows domain rejections to their stable codes at the wire boundary.
-import { GoalError } from '@deepseek-ai/dsh-goal'
-import type { GoalRef as CoreGoalRef } from '@deepseek-ai/dsh-goal'
 // Type-only edges: resolve the command-change stream and `ctx.get('skills')`.
 import type {} from '@deepseek-ai/dsh-commands'
 import type {} from '@deepseek-ai/dsh-skill'
@@ -270,47 +267,6 @@ export function createApiProxy(ctx: Context, defaults: ApiProxyDefaults): ApiPro
     }
   }
 
-  /**
-   * Resolve the goal service THIS agent runs.
-   *
-   * The service is per session: an agent preset mounts it behind an `isolate`
-   * realm, which no host context resolves. Reading it from the root would
-   * answer "absent" for a session whose composition mounts it — so the lookup
-   * is keyed by the agent, and only a deployment composing it nowhere is
-   * genuinely absent.
-   */
-  function goalServiceFor(agent: Agent): NonNullable<ReturnType<typeof ctx.get<'goals'>>> | { error: RpcError } {
-    const presets = ctx.get('agentPresets')
-    const goals = presets?.serviceFor(agent, 'goals') ?? ctx.get('goals')
-    if (goals === undefined) {
-      return { error: { code: 'internal', message: 'goal service is absent: neither this session\'s agent preset nor the host composition mounts @deepseek-ai/dsh-goal', details: {} } }
-    }
-    return goals
-  }
-
-  /** Map one goal-domain rejection to the wire error (stable GoalError codes ride in details). */
-  function goalError(request: RpcRequest<unknown>, error: unknown): RpcResponse<never> {
-    const details = error instanceof GoalError ? { goalCode: error.code } : {}
-    return err(request, { code: 'internal', message: String(error), details })
-  }
-
-  /** Resolve a session's agent, apply one goal mutation, and acknowledge with the new CAS ref. */
-  async function mutateGoal(
-    request: RpcRequest<{ sessionId: SessionId }>,
-    mutation: (goals: NonNullable<ReturnType<typeof ctx.get<'goals'>>>, agent: Agent) => CoreGoalRef,
-  ): Promise<RpcResponse<{ ref: GoalRef }>> {
-    const found = await agentFor(request.payload.sessionId)
-    if ('error' in found) return err(request, found.error)
-    const goals = goalServiceFor(found.agent)
-    if ('error' in goals) return err(request, goals.error)
-    try {
-      const ref = mutation(goals, found.agent)
-      return ok(request, { ref: { id: ref.id, revision: ref.revision } })
-    } catch (error: unknown) {
-      return goalError(request, error)
-    }
-  }
-
   /** Missing-service report shared by the settings domain (skills-domain stance). */
   function settingsAbsent(): RpcError {
     return { code: 'internal', message: 'settings service is absent: this deployment does not mount a settings provider (e.g. @deepseek-ai/dsh-settings-file) in its composition', details: {} }
@@ -623,54 +579,6 @@ export function createApiProxy(ctx: Context, defaults: ApiProxyDefaults): ApiPro
       },
     },
 
-    goals: {
-      // Mutations only — the read side is the 'goal' session projection.
-      // Every verb resolves the session's agent (agentFor: implicit cold
-      // resume, the command.* precedent) and acknowledges with the new CAS
-      // ref; the committed goal/change event carries the whole value to every
-      // client through the projection frames.
-      async create(request) {
-        const { objective, maxGoalRounds } = request.payload
-        return mutateGoal(request, (goals, agent) => goals.create(agent, {
-          objective,
-          ...(maxGoalRounds !== undefined ? { maxGoalRounds } : {}),
-        }))
-      },
-
-      async edit(request) {
-        const { ref, objective, maxGoalRounds } = request.payload
-        return mutateGoal(request, (goals, agent) => goals.edit(agent, ref, {
-          ...(objective !== undefined ? { objective } : {}),
-          ...(maxGoalRounds !== undefined ? { maxGoalRounds } : {}),
-        }))
-      },
-
-      async pause(request) {
-        return mutateGoal(request, (goals, agent) => goals.pause(agent, request.payload.ref))
-      },
-
-      async resume(request) {
-        return mutateGoal(request, (goals, agent) => goals.resume(agent, request.payload.ref))
-      },
-
-      async complete(request) {
-        return mutateGoal(request, (goals, agent) => goals.complete(agent, request.payload.ref))
-      },
-
-      async clear(request) {
-        const found = await agentFor(request.payload.sessionId)
-        if ('error' in found) return err(request, found.error)
-        const goals = goalServiceFor(found.agent)
-        if ('error' in goals) return err(request, goals.error)
-        try {
-          goals.clear(found.agent, request.payload.ref)
-          return ok(request, { cleared: true as const })
-        } catch (error: unknown) {
-          return goalError(request, error)
-        }
-      },
-    },
-
     agentPresets: {
       // A deployment with no roster answers with an empty list rather than an
       // error: composing no presets is a valid deployment, and the browser

packages/host/apiproxy/src/api/goals.schema.ts

@@ -1,79 +0,0 @@
-/**
- * goals domain zod schemas. Mutation-only shapes: every value schema is a
- * `{ ref }` acknowledgement (clear: `{ cleared }`) — the current goal state
- * travels exclusively on the 'goal' session projection.
- */
-
-import { z } from 'zod'
-import type { Wire } from './rpc.schema.ts'
-import type { GoalRef, RequestPayload, ResponseValue } from './index.ts'
-
-/** GoalRef schema. */
-export const goalRefSchema = z.object({
-  id: z.string(),
-  revision: z.number().int().positive(),
-}) as unknown as z.ZodType<Wire<GoalRef>>
-
-/** Shared `{ ref }` acknowledgement value of every non-clear mutation. */
-const goalRefValueSchema = z.object({ ref: goalRefSchema })
-
-/** goal.create request payload. */
-export const goalCreateRequestSchema = z.object({
-  sessionId: z.string(),
-  objective: z.string().min(1),
-  maxGoalRounds: z.number().int().positive().optional(),
-}) as unknown as z.ZodType<Wire<RequestPayload<'goal.create'>>>
-
-/** goal.create response value. */
-export const goalCreateValueSchema = goalRefValueSchema as unknown as z.ZodType<Wire<ResponseValue<'goal.create'>>>
-
-/** goal.edit request payload. */
-export const goalEditRequestSchema = z.object({
-  sessionId: z.string(),
-  ref: goalRefSchema,
-  objective: z.string().min(1).optional(),
-  maxGoalRounds: z.number().int().positive().optional(),
-}).refine(value => value.objective !== undefined || value.maxGoalRounds !== undefined, {
-  message: 'goal.edit requires objective or maxGoalRounds',
-}) as unknown as z.ZodType<Wire<RequestPayload<'goal.edit'>>>
-
-/** goal.edit response value. */
-export const goalEditValueSchema = goalRefValueSchema as unknown as z.ZodType<Wire<ResponseValue<'goal.edit'>>>
-
-/** goal.pause request payload. */
-export const goalPauseRequestSchema = z.object({
-  sessionId: z.string(),
-  ref: goalRefSchema,
-}) as unknown as z.ZodType<Wire<RequestPayload<'goal.pause'>>>
-
-/** goal.pause response value. */
-export const goalPauseValueSchema = goalRefValueSchema as unknown as z.ZodType<Wire<ResponseValue<'goal.pause'>>>
-
-/** goal.resume request payload. */
-export const goalResumeRequestSchema = z.object({
-  sessionId: z.string(),
-  ref: goalRefSchema,
-}) as unknown as z.ZodType<Wire<RequestPayload<'goal.resume'>>>
-
-/** goal.resume response value. */
-export const goalResumeValueSchema = goalRefValueSchema as unknown as z.ZodType<Wire<ResponseValue<'goal.resume'>>>
-
-/** goal.complete request payload. */
-export const goalCompleteRequestSchema = z.object({
-  sessionId: z.string(),
-  ref: goalRefSchema,
-}) as unknown as z.ZodType<Wire<RequestPayload<'goal.complete'>>>
-
-/** goal.complete response value. */
-export const goalCompleteValueSchema = goalRefValueSchema as unknown as z.ZodType<Wire<ResponseValue<'goal.complete'>>>
-
-/** goal.clear request payload. */
-export const goalClearRequestSchema = z.object({
-  sessionId: z.string(),
-  ref: goalRefSchema,
-}) as unknown as z.ZodType<Wire<RequestPayload<'goal.clear'>>>
-
-/** goal.clear response value. */
-export const goalClearValueSchema = z.object({
-  cleared: z.literal(true),
-}) as unknown as z.ZodType<Wire<ResponseValue<'goal.clear'>>>

packages/host/apiproxy/src/api/goals.ts

@@ -1,53 +0,0 @@
-/**
- * goals domain contract. Method signatures are the source of truth:
- * unary methods take the RpcRequest<P> narrow form and the impl echoes rpcId.
- *
- * Mutations only: the read side is the `goal` Session projection carried by
- * Session Controller history and control streams. There is no goal.get or
- * separate wire goal view; responses acknowledge with the new CAS ref, and
- * committed goal/change events update the projection.
- */
-
-import type { Branded } from '@deepseek-ai/dsh-brand'
-import type { SessionId } from '@deepseek-ai/dsh-session/types'
-import type { RpcRequest, RpcResponse } from './rpc.ts'
-
-/** Identifies one goal across its durable revisions. */
-export type GoalId = Branded<'GoalId'>
-
-/** Compare-and-set identity for one exact goal revision. */
-export interface GoalRef {
-  readonly id: GoalId
-  readonly revision: number
-}
-
-/**
- * Goal-domain unary methods. Every mutation resolves an ordinary session's
- * Agent and applies one CAS-guarded verb; session-backed subagents reject with
- * `agent-busy`.
- */
-export interface GoalsApi {
-  /** Create and arm a goal. */
-  create(request: RpcRequest<{ sessionId: SessionId; objective: string; maxGoalRounds?: number }>):
-  Promise<RpcResponse<{ ref: GoalRef }>>
-
-  /** Edit objective and/or round cap without changing phase. */
-  edit(request: RpcRequest<{ sessionId: SessionId; ref: GoalRef; objective?: string; maxGoalRounds?: number }>):
-  Promise<RpcResponse<{ ref: GoalRef }>>
-
-  /** Pause an active goal and disarm automatic continuation. */
-  pause(request: RpcRequest<{ sessionId: SessionId; ref: GoalRef }>):
-  Promise<RpcResponse<{ ref: GoalRef }>>
-
-  /** Resume and arm a stopped goal. */
-  resume(request: RpcRequest<{ sessionId: SessionId; ref: GoalRef }>):
-  Promise<RpcResponse<{ ref: GoalRef }>>
-
-  /** Mark a current non-complete goal complete and disarm it. */
-  complete(request: RpcRequest<{ sessionId: SessionId; ref: GoalRef }>):
-  Promise<RpcResponse<{ ref: GoalRef }>>
-
-  /** Clear the current goal while retaining a durable tombstone and history. */
-  clear(request: RpcRequest<{ sessionId: SessionId; ref: GoalRef }>):
-  Promise<RpcResponse<{ cleared: true }>>
-}

packages/host/apiproxy/src/api/index.ts

@@ -8,7 +8,6 @@ import type { HostApi } from './host.ts'
 import type { AgentPresetsApi } from './agent-presets.ts'
 import type { SkillsApi } from './skills.ts'
 import type { SubagentsApi } from './subagents.ts'
-import type { GoalsApi } from './goals.ts'
 import type { SettingsApi } from './settings.ts'
 import type { CredentialsApi } from './credentials.ts'
 import type { LlmApi } from './llm.ts'
@@ -20,7 +19,6 @@ export interface ApiProxy {
   host: HostApi
   skills: SkillsApi
   agentPresets: AgentPresetsApi
-  goals: GoalsApi
   settings: SettingsApi
   credentials: CredentialsApi
   llm: LlmApi
@@ -40,7 +38,6 @@ export type {
 } from './subagents.ts'
 export type { SkillsApi, SkillEntry } from './skills.ts'
 export type { AgentPresetsApi, AgentPresetEntry } from './agent-presets.ts'
-export type { GoalsApi, GoalId, GoalRef } from './goals.ts'
 export type { SettingsApi, SettingsNamespaceView, SettingsPathOpView, SettingsSecretView } from './settings.ts'
 export type { CredentialsApi, CredentialView } from './credentials.ts'
 export type { ConfigurableProviderView, DiscoveredModelView, LlmApi } from './llm.ts'

packages/host/apiproxy/src/api/rpc-map.ts

@@ -6,7 +6,6 @@
 import type { HostApi } from './host.ts'
 import type { AgentPresetsApi } from './agent-presets.ts'
 import type { SkillsApi } from './skills.ts'
-import type { GoalsApi } from './goals.ts'
 import type { SettingsApi } from './settings.ts'
 import type { CredentialsApi } from './credentials.ts'
 import type { LlmApi } from './llm.ts'
@@ -34,12 +33,6 @@ export interface RpcMethodMap {
   'agentPreset.copy': AgentPresetsApi['copy']
   'agentPreset.openDocument': AgentPresetsApi['openDocument']
   'agentPreset.remove': AgentPresetsApi['remove']
-  'goal.create': GoalsApi['create']
-  'goal.edit': GoalsApi['edit']
-  'goal.pause': GoalsApi['pause']
-  'goal.resume': GoalsApi['resume']
-  'goal.complete': GoalsApi['complete']
-  'goal.clear': GoalsApi['clear']
   'settings.describe': SettingsApi['describe']
   'settings.openDocument': SettingsApi['openDocument']
   'settings.update': SettingsApi['update']

packages/host/apiproxy/src/fetch/client.ts

@@ -21,14 +21,6 @@ import {
   agentPresetCopyValueSchema, agentPresetListValueSchema, agentPresetOpenDocumentValueSchema,
   agentPresetReadValueSchema, agentPresetRemoveValueSchema, agentPresetSelectValueSchema,
 } from '../api/agent-presets.schema.ts'
-import {
-  goalCreateValueSchema,
-  goalEditValueSchema,
-  goalPauseValueSchema,
-  goalResumeValueSchema,
-  goalCompleteValueSchema,
-  goalClearValueSchema,
-} from '../api/goals.schema.ts'
 import {
   settingsDescribeValueSchema, settingsMutateValueSchema, settingsOpenDocumentValueSchema,
   settingsReplaceValueSchema, settingsUpdateValueSchema,
@@ -79,14 +71,6 @@ export interface IApiClient {
     openDocument(payload: RequestPayload<'agentPreset.openDocument'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'agentPreset.openDocument'>>>
     remove(payload: RequestPayload<'agentPreset.remove'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'agentPreset.remove'>>>
   }
-  goals: {
-    create(payload: RequestPayload<'goal.create'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'goal.create'>>>
-    edit(payload: RequestPayload<'goal.edit'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'goal.edit'>>>
-    pause(payload: RequestPayload<'goal.pause'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'goal.pause'>>>
-    resume(payload: RequestPayload<'goal.resume'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'goal.resume'>>>
-    complete(payload: RequestPayload<'goal.complete'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'goal.complete'>>>
-    clear(payload: RequestPayload<'goal.clear'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'goal.clear'>>>
-  }
   settings: {
     describe(payload: RequestPayload<'settings.describe'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'settings.describe'>>>
     openDocument(payload: RequestPayload<'settings.openDocument'>, signal?: AbortSignal): Promise<RpcResponse<ResponseValue<'settings.openDocument'>>>
@@ -126,12 +110,6 @@ const UNARY_VALUE_SCHEMAS: { [K in keyof RpcMethodMap]: z.ZodType<Wire<ResponseV
   'agentPreset.copy': agentPresetCopyValueSchema,
   'agentPreset.openDocument': agentPresetOpenDocumentValueSchema,
   'agentPreset.remove': agentPresetRemoveValueSchema,
-  'goal.create': goalCreateValueSchema,
-  'goal.edit': goalEditValueSchema,
-  'goal.pause': goalPauseValueSchema,
-  'goal.resume': goalResumeValueSchema,
-  'goal.complete': goalCompleteValueSchema,
-  'goal.clear': goalClearValueSchema,
   'settings.describe': settingsDescribeValueSchema,
   'settings.openDocument': settingsOpenDocumentValueSchema,
   'settings.update': settingsUpdateValueSchema,
@@ -309,15 +287,6 @@ export abstract class AbstractApiClient implements IApiClient {
     remove: (payload, signal) => this.callUnary('agentPreset.remove', payload, signal),
   }
 
-  readonly goals: IApiClient['goals'] = {
-    create: (payload, signal) => this.callUnary('goal.create', payload, signal),
-    edit: (payload, signal) => this.callUnary('goal.edit', payload, signal),
-    pause: (payload, signal) => this.callUnary('goal.pause', payload, signal),
-    resume: (payload, signal) => this.callUnary('goal.resume', payload, signal),
-    complete: (payload, signal) => this.callUnary('goal.complete', payload, signal),
-    clear: (payload, signal) => this.callUnary('goal.clear', payload, signal),
-  }
-
   readonly settings: IApiClient['settings'] = {
     describe: (payload, signal) => this.callUnary('settings.describe', payload, signal),
     openDocument: (payload, signal) => this.callUnary('settings.openDocument', payload, signal),

packages/host/apiproxy/src/fetch/handler.ts

@@ -24,14 +24,6 @@ import {
   agentPresetCopyRequestSchema, agentPresetListRequestSchema, agentPresetOpenDocumentRequestSchema,
   agentPresetReadRequestSchema, agentPresetRemoveRequestSchema, agentPresetSelectRequestSchema,
 } from '../api/agent-presets.schema.ts'
-import {
-  goalCreateRequestSchema,
-  goalEditRequestSchema,
-  goalPauseRequestSchema,
-  goalResumeRequestSchema,
-  goalCompleteRequestSchema,
-  goalClearRequestSchema,
-} from '../api/goals.schema.ts'
 import {
   settingsDescribeRequestSchema, settingsMutateRequestSchema, settingsOpenDocumentRequestSchema,
   settingsReplaceRequestSchema, settingsUpdateRequestSchema,
@@ -78,12 +70,6 @@ const UNARY_ROUTES: UnaryRoutes = {
   'agentPreset.copy': { schema: agentPresetCopyRequestSchema, invoke: (api, r) => api.agentPresets.copy(r) },
   'agentPreset.openDocument': { schema: agentPresetOpenDocumentRequestSchema, invoke: (api, r, signal) => api.agentPresets.openDocument(r, signal) },
   'agentPreset.remove': { schema: agentPresetRemoveRequestSchema, invoke: (api, r) => api.agentPresets.remove(r) },
-  'goal.create': { schema: goalCreateRequestSchema, invoke: (api, r) => api.goals.create(r) },
-  'goal.edit': { schema: goalEditRequestSchema, invoke: (api, r) => api.goals.edit(r) },
-  'goal.pause': { schema: goalPauseRequestSchema, invoke: (api, r) => api.goals.pause(r) },
-  'goal.resume': { schema: goalResumeRequestSchema, invoke: (api, r) => api.goals.resume(r) },
-  'goal.complete': { schema: goalCompleteRequestSchema, invoke: (api, r) => api.goals.complete(r) },
-  'goal.clear': { schema: goalClearRequestSchema, invoke: (api, r) => api.goals.clear(r) },
   'settings.describe': { schema: settingsDescribeRequestSchema, invoke: (api, r) => api.settings.describe(r) },
   'settings.openDocument': { schema: settingsOpenDocumentRequestSchema, invoke: (api, r, signal) => api.settings.openDocument(r, signal) },
   'settings.update': { schema: settingsUpdateRequestSchema, invoke: (api, r) => api.settings.update(r) },

packages/host/apiproxy/src/index.ts

@@ -74,7 +74,6 @@ export class ApiProxyService extends Service implements ApiProxy {
 
   readonly subagents: ApiProxy['subagents']
   readonly host: ApiProxy['host']
-  readonly goals: ApiProxy['goals']
   readonly skills: ApiProxy['skills']
   readonly agentPresets: ApiProxy['agentPresets']
   readonly settings: ApiProxy['settings']
@@ -94,7 +93,6 @@ export class ApiProxyService extends Service implements ApiProxy {
     })
     this.subagents = api.subagents
     this.host = api.host
-    this.goals = api.goals
     this.skills = api.skills
     this.agentPresets = api.agentPresets
     this.settings = api.settings

packages/host/apiproxy/tests/api-proxy-agent-preset.spec.ts

@@ -13,7 +13,6 @@ import {
   agentPresetProjectionDefinition, InvalidPresetIdError, PresetExistsError, UnknownPresetError,
 } from '@deepseek-ai/dsh-agent-presets'
 import type {} from '@deepseek-ai/dsh-agent-presets/types'
-import { GoalId } from '@deepseek-ai/dsh-goal'
 import { createApiProxy } from '../src/api-proxy.ts'
 import { describe, expect, it } from 'vitest'
 import { SessionQueryError, type SessionObservation } from '@deepseek-ai/dsh-session-query'
@@ -210,23 +209,6 @@ async function harness(
  * instance through the agent instead of reading a root-realm singleton.
  */
 describe('a capability the session\'s preset mounts', () => {
-  it('serves the goal RPC from the session\'s own goal service', async () => {
-    const { api } = await harness(['standard'])
-    await createSession(api, { sessionId: SessionId('g1'), agentPreset: 'standard' })
-    const ref = { id: GoalId('goal-1'), revision: 1 }
-    const paused: unknown[] = []
-    services.set('g1', {
-      goals: { pause: (agent: { id: unknown }, r: unknown) => { paused.push([String(agent.id), r]); return ref } },
-    })
-
-    const response = await api.goals.pause(request({ sessionId: SessionId('g1'), ref }))
-
-    expect(response.result).toMatchObject({ ok: true, value: { ref } })
-    // Reached the instance this session mounted, and was handed its own agent.
-    expect(paused).toEqual([['g1', ref]])
-    services.delete('g1')
-  })
-
   it('serves the skill catalog from the session\'s own registry', async () => {
     const { api } = await harness(['standard'])
     await createSession(api, { sessionId: SessionId('k1'), agentPreset: 'standard' })

packages/host/apiproxy/tests/client-handler.spec.ts

@@ -7,7 +7,7 @@
 
 import { describe, expect, it, vi } from 'vitest'
 import type { SessionId } from '@deepseek-ai/dsh-session'
-import type { ApiProxy, GoalRef, RpcMessage, RpcRequest, RpcResponse } from '@deepseek-ai/dsh-host-apiproxy'
+import type { ApiProxy, RpcMessage, RpcRequest, RpcResponse } from '@deepseek-ai/dsh-host-apiproxy'
 import { InProcessApiClient, RpcId, toFetchHandler } from '@deepseek-ai/dsh-host-apiproxy'
 
 const sid = (id: string): SessionId => id as SessionId
@@ -22,7 +22,6 @@ function scriptedApi(overrides: {
   host?: Partial<ApiProxy['host']>
   skills?: Partial<ApiProxy['skills']>
   agentPresets?: Partial<ApiProxy['agentPresets']>
-  goals?: Partial<ApiProxy['goals']>
   settings?: Partial<ApiProxy['settings']>
   credentials?: Partial<ApiProxy['credentials']>
   llm?: Partial<ApiProxy['llm']>
@@ -56,15 +55,6 @@ function scriptedApi(overrides: {
       remove: r => ok(r, {}),
       ...overrides.agentPresets,
     },
-    goals: {
-      create: err,
-      edit: err,
-      pause: err,
-      resume: err,
-      complete: err,
-      clear: err,
-      ...overrides.goals,
-    },
     settings: {
       describe: r => ok(r, { writable: true, hasDocument: false, namespaces: [] }),
       openDocument: r => ok(r, { opened: true as const }),
@@ -309,63 +299,6 @@ describe('unary round trip', () => {
   })
 })
 
-describe('goals unary surface', () => {
-  const ref: GoalRef = { id: 'goal-1' as GoalRef['id'], revision: 1 }
-  /** The `{ ref }` acknowledgement every non-clear mutation answers (state travels on the projection). */
-  const ack = { ref: { id: 'goal-1' as GoalRef['id'], revision: 2 } }
-
-  it('round-trips every goal method with its own payload and value shape', async () => {
-    const seen: { method: string; payload: unknown }[] = []
-    const record = recorderInto(seen)
-    const api = scriptedApi({
-      goals: {
-        create: record('goal.create', r => ok(r, ack)),
-        edit: record('goal.edit', r => ok(r, { ref: { ...ack.ref, revision: 3 } })),
-        pause: record('goal.pause', r => ok(r, ack)),
-        resume: record('goal.resume', r => ok(r, ack)),
-        complete: record('goal.complete', r => ok(r, ack)),
-        clear: record('goal.clear', r => ok(r, { cleared: true as const })),
-      },
-    })
-    const c = client(api)
-
-    const created = await c.goals.create({ sessionId: sid('s1'), objective: 'ship it', maxGoalRounds: 4 })
-    expect(created.result).toEqual({ ok: true, value: ack })
-    const edited = await c.goals.edit({ sessionId: sid('s1'), ref, objective: 'ship v2' })
-    expect(edited.result).toEqual({ ok: true, value: { ref: { ...ack.ref, revision: 3 } } })
-    expect((await c.goals.pause({ sessionId: sid('s1'), ref })).result).toEqual({ ok: true, value: ack })
-    expect((await c.goals.resume({ sessionId: sid('s1'), ref })).result).toEqual({ ok: true, value: ack })
-    expect((await c.goals.complete({ sessionId: sid('s1'), ref })).result).toEqual({ ok: true, value: ack })
-    const cleared = await c.goals.clear({ sessionId: sid('s1'), ref })
-    expect(cleared.result).toEqual({ ok: true, value: { cleared: true } })
-
-    // The handler dispatched each call through its own route row: payload parsed per method.
-    expect(seen.map(s => s.method)).toEqual(['goal.create', 'goal.edit', 'goal.pause', 'goal.resume', 'goal.complete', 'goal.clear'])
-    expect(seen[0]?.payload).toEqual({ sessionId: 's1', objective: 'ship it', maxGoalRounds: 4 })
-    expect(seen[1]?.payload).toEqual({ sessionId: 's1', ref, objective: 'ship v2' })
-  })
-
-  it('passes business errors through as results, not throws', async () => {
-    // Default scripted goals impl answers an err result: it must arrive as a result, not a throw.
-    const failed = await client(scriptedApi()).goals.pause({ sessionId: sid('s1'), ref })
-    expect(failed.result.ok).toBe(false)
-    if (!failed.result.ok) expect(failed.result.error.code).toBe('internal')
-  })
-
-  it('rejects an invalid goal payload at the handler as bad-request', async () => {
-    const response = await client(scriptedApi()).goals.create({ sessionId: sid('s1'), objective: '' })
-    expect(response.result.ok).toBe(false)
-    if (!response.result.ok) expect(response.result.error.code).toBe('bad-request')
-
-    let editCalls = 0
-    const api = scriptedApi({ goals: { edit: (r) => { editCalls++; return ok(r, ack) } } })
-    const emptyEdit = await client(api).goals.edit({ sessionId: sid('s1'), ref })
-    expect(emptyEdit.result.ok).toBe(false)
-    if (!emptyEdit.result.ok) expect(emptyEdit.result.error.code).toBe('bad-request')
-    expect(editCalls).toBe(0)
-  })
-})
-
 describe('envelope tap', () => {
   it('delivers one microtask batch of full forms per unary call', async () => {
     const api = scriptedApi()

packages/host/apiproxy/tests/fetch-carrier.spec.ts

@@ -87,26 +87,6 @@ function fakeApi(overrides: Partial<{ crashOn: string }> = {}): ApiProxy {
         return { rpcId: request.rpcId, result: { ok: true, value: { skills: [{ name: 'commit-helper', description: 'Git commits', modelInvocable: true }] } } }
       },
     },
-    goals: {
-      async create(request) {
-        return { rpcId: request.rpcId, result: { ok: false, error: { code: 'internal', message: 'stub', details: {} } } }
-      },
-      async edit(request) {
-        return { rpcId: request.rpcId, result: { ok: false, error: { code: 'internal', message: 'stub', details: {} } } }
-      },
-      async pause(request) {
-        return { rpcId: request.rpcId, result: { ok: false, error: { code: 'internal', message: 'stub', details: {} } } }
-      },
-      async resume(request) {
-        return { rpcId: request.rpcId, result: { ok: false, error: { code: 'internal', message: 'stub', details: {} } } }
-      },
-      async complete(request) {
-        return { rpcId: request.rpcId, result: { ok: false, error: { code: 'internal', message: 'stub', details: {} } } }
-      },
-      async clear(request) {
-        return { rpcId: request.rpcId, result: { ok: false, error: { code: 'internal', message: 'stub', details: {} } } }
-      },
-    },
     settings: {
       async describe(request) {
         return { rpcId: request.rpcId, result: { ok: true, value: { writable: true, hasDocument: false, namespaces: [] } } }

packages/host/apiproxy/tests/rpc-schemas.spec.ts

@@ -14,7 +14,6 @@ import { skillEntrySchema, skillListRequestSchema, skillListValueSchema } from '
 import {
   agentPresetEntrySchema, agentPresetListValueSchema, agentPresetOpenDocumentValueSchema,
 } from '../src/api/agent-presets.schema.ts'
-import { goalEditRequestSchema } from '../src/api/goals.schema.ts'
 import { subagentPromptRequestSchema } from '../src/api/subagents.schema.ts'
 
 describe('RpcId', () => {
@@ -178,15 +177,6 @@ describe('skills domain schemas', () => {
   })
 })
 
-describe('goals domain schemas', () => {
-  it('requires at least one replacement field for goal.edit', () => {
-    const ref = { id: 'g1', revision: 1 }
-    expect(goalEditRequestSchema.parse({ sessionId: 's1', ref, objective: 'updated' }).objective).toBe('updated')
-    expect(goalEditRequestSchema.parse({ sessionId: 's1', ref, maxGoalRounds: 3 }).maxGoalRounds).toBe(3)
-    expect(() => goalEditRequestSchema.parse({ sessionId: 's1', ref })).toThrow()
-  })
-})
-
 describe('agent-preset schemas', () => {
   it('accepts a roster row and rejects an unknown trust', () => {
     expect(agentPresetEntrySchema.parse({ id: 'standard', trust: 'system', isDefault: true }))

packages/host/apiproxy/tsconfig.json

@@ -8,9 +8,6 @@
     "src"
   ],
   "references": [
-    {
-      "path": "../../goal/goal"
-    },
     {
       "path": "../../settings/settings"
     },

pnpm-lock.yaml

@@ -1597,12 +1597,12 @@ importers:
       '@deepseek-ai/dsh-attachment':
         specifier: workspace:^
         version: link:../../attachment/attachment
-      '@deepseek-ai/dsh-credentials':
-        specifier: workspace:^
-        version: link:../../credentials/credentials
       '@deepseek-ai/dsh-commands':
         specifier: workspace:^
         version: link:../../interaction/commands
+      '@deepseek-ai/dsh-credentials':
+        specifier: workspace:^
+        version: link:../../credentials/credentials
       '@deepseek-ai/dsh-host-apiproxy':
         specifier: workspace:^
         version: link:../../host/apiproxy
@@ -5559,9 +5559,6 @@ importers:
       '@deepseek-ai/dsh-credentials':
         specifier: workspace:^
         version: link:../../credentials/credentials
-      '@deepseek-ai/dsh-goal':
-        specifier: workspace:^
-        version: link:../../goal/goal
       '@deepseek-ai/dsh-host-directory-picker':
         specifier: workspace:^
         version: link:../directory-picker