chore: take real people out of the tests, and out of the prompt

Test fixtures carried colleagues' names and their work email addresses,
and one of them had reached the shipped system instruction: the example
approval question named a real person. A repository that is about to be
public should not introduce anyone by name who did not ask to be there.

Fictional stand-ins replace them, in the same script so the tests still
exercise what they were written for — Korean name resolution stays
Korean — and every assertion moved with its fixture rather than being
loosened. The example company keeps its shape and loses its identity.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: eastriverlee

README.md

@@ -6,57 +6,87 @@ bluecollar does not own tools, identity, or storage. It is handed a tool set and
 host and runs the turn. That separation is the point — the same loop runs behind a chat connector on
 a server, or in front of you in a terminal.
 
+It is built for work nobody is watching. A request arrives from someone else, the person who sent it
+goes back to their day, and the answer has to be right without anyone checking. That assumption is
+why the loop carries things an interactive coding agent has no use for: an outcome contract agreed
+before the work starts, a completion gate that will not accept the model's own word that it is done,
+approval as a state a task can sit in for days and resume from, a tier ladder that picks the model
+from the difficulty rather than from a flag, and failure text written for the person who asked
+rather than for a log.
+
+The trade is real and worth stating plainly: it is heavier than an interactive loop, and for sitting
+beside a developer and fixing code as they watch, a coding agent is the better tool.
+
 ## The shape
 
 ```
 host  ──── agentcontract.Harness ────  bluecollar
   │                                        │
   │ owns: tools, identity, task store,     │ owns: the turn loop, routing,
-  │       approvals, POSIX isolation       │       skills, completion judgment
+  │       approvals, process isolation     │       skills, completion judgment
   │                                        │
   └──────── executes every tool call ──────┘
 ```
 
 The host and the harness compile against one shared contract package,
-[`agentcontract`](./agentcontract).
-The host names only that interface, never this package. A different harness — an AI SDK adapter, an
-external agent — drops into the same socket.
-
-The nine verbs the host may call:
-
-| Verb | Purpose |
-|---|---|
-| `RunTurn` | Run one turn of an existing task |
-| `RouteTurn` | Decide what an inbound message means before running anything |
-| `RunAgentRequest` | Route and run in one call |
-| `CompleteLaunchFailure` | Turn a launch failure into an explanation for the person |
-| `GenerateReply` | One-shot reply, no task |
-| `GenerateReplyWithContext` | One-shot reply with visible context and memory |
-| `ClassifyAddressing` | Decide whether a message in a channel is for us |
-| `ClassifyActiveTaskFollowUp` | Decide whether a message continues a running task |
-| `RefreshSkillIndex` | Re-read the skill bundle |
+[`agentcontract`](./agentcontract). A different harness — an AI SDK adapter, an external agent —
+drops into the same socket.
+
+The port is one method:
+
+```go
+type Harness interface {
+	RunTurn(context.Context, AgentTurnRequest) (AgentTurnResult, error)
+}
+```
+
+It used to be nine. Routing, addressing, follow-up classification and one-shot replies were verbs on
+the port until it became clear they are host policy, not harness behaviour: a host that answers
+its own messenger decides what an inbound message *means* before anything runs a turn. Those
+still live here — [`intake.Classifier`](./intake) routes and classifies, `AgentKernel` carries
+`RunAgentRequest` and `CompleteLaunchFailure` — but a host is free to bring its own, and a harness
+that implements only `RunTurn` is complete.
 
 Tool execution never happens here. The harness decides *what* to call; the host decides *who* it runs
 as. A harness that runs its own tools defeats the host's isolation boundary and is not a valid
 implementation of this contract.
 
+The harness has no identity of its own. The host supplies `AgentIdentity`, the workspace layout, the
+instruction bundle and the company context; with none given, the agent is "the assistant" and knows
+nothing about where it runs.
+
 ## Provider-agnostic
 
 Models reach bluecollar through a provider port, not a vendor SDK. Anything satisfying it works, and
 the provider can change **between steps of a running turn** — the tier ladder relies on that, escalating
 a task from a cheap model to a strong one without restarting it.
 
-The reference provider is an [AI SDK](https://ai-sdk.dev) sidecar, which is what makes "any model"
-literal rather than aspirational.
+There is no provider implementation in this module — the port is the contract, and the host brings
+the provider. The reference one, in [blueclaw](https://github.com/Dawn-kim-official/blueclaw), is an
+[AI SDK](https://ai-sdk.dev) sidecar, which is what makes "any model" literal rather than
+aspirational.
 
 ## What is not here yet
 
 Honest list, kept current:
 
-- The terminal CLI. Planned on [termcn](https://github.com/shadcn-labs/termcn).
+- A terminal front end of its own. Planned on [termcn](https://github.com/shadcn-labs/termcn); today
+  the only way to drive the loop is to embed it in a host.
 - Native multi-step tool calling. The loop currently forces one structured action per step, which
   costs a turn per tool call and blocks parallel calls. Migration is planned and staged.
 
+## Building and testing
+
+The module depends on one library and nothing outside its own directory.
+
+```
+go build ./...
+go test ./...
+```
+
+Every check that runs in CI is in [`.github/workflows/check.yml`](./.github/workflows/check.yml):
+`gofmt`, `go vet`, `go build`, `go test`. No network, no credentials, no database.
+
 ## License
 
 MIT. See [LICENSE](./LICENSE).

approval_gate_test.go

@@ -239,7 +239,7 @@ func TestCurrentThreadSendSkipsRuntimeApproval(t *testing.T) {
 	if toolCallRequiresRuntimeApproval(toolSet, currentChannelCall) {
 		t.Fatal("expected a current-channel send to run without approval, like a reply")
 	}
-	directMessageCall := turnActionDocument{ToolName: "message_send", ToolInput: json.RawMessage(`{"targetType":"directMessage","personHint":"우경","message":"안내"}`)}
+	directMessageCall := turnActionDocument{ToolName: "message_send", ToolInput: json.RawMessage(`{"targetType":"directMessage","personHint":"테스트","message":"안내"}`)}
 	if !toolCallRequiresRuntimeApproval(toolSet, directMessageCall) {
 		t.Fatal("expected an external send to keep requiring approval")
 	}

approval_gate_wording_test.go

@@ -67,28 +67,28 @@ func TestHeldCallConfirmationWordingAsksModelForDeclarativeDraft(t *testing.T) {
 
 func TestHeldCallConfirmationWordingUsesActionFactsAsModelInput(t *testing.T) {
 	languageModel := &sequenceLanguageModel{contents: []string{
-		`{"question":"우경에게 다음 내용을 보낼까요?\n\n오늘 오후 3시에 확인하자"}`,
+		`{"question":"테스트에게 다음 내용을 보낼까요?\n\n오늘 오후 3시에 확인하자"}`,
 	}}
 	agentTurnRunner := &AgentTurnRunner{languageModel: languageModel}
 	request := AgentTurnRequest{
-		Prompt:           "우경에게 DM 보내줘",
+		Prompt:           "테스트에게 DM 보내줘",
 		ResponseLanguage: ResponseLanguageKorean,
 	}
 	actionDocument := turnActionDocument{
 		ToolName:  "message_send",
-		ToolInput: json.RawMessage(`{"targetType":"directMessage","personHint":"우경","message":"오늘 오후 3시에 확인하자"}`),
+		ToolInput: json.RawMessage(`{"targetType":"directMessage","personHint":"테스트","message":"오늘 오후 3시에 확인하자"}`),
 	}
 
 	confirmation, errorValue := agentTurnRunner.heldCallConfirmationWording(context.Background(), request, actionDocument)
 
 	if errorValue != nil {
 		t.Fatalf("expected no error: %v", errorValue)
 	}
-	if confirmation != "우경에게 다음 내용을 보낼까요?\n\n오늘 오후 3시에 확인하자" {
+	if confirmation != "테스트에게 다음 내용을 보낼까요?\n\n오늘 오후 3시에 확인하자" {
 		t.Fatalf("expected model-generated question with message content, got %q", confirmation)
 	}
 	requestText := structuredRequestText(languageModel.requests[0])
-	for _, expected := range []string{"우경", "오늘 오후 3시에 확인하자", "Do not mention internal tool names"} {
+	for _, expected := range []string{"테스트", "오늘 오후 3시에 확인하자", "Do not mention internal tool names"} {
 		if !strings.Contains(requestText, expected) {
 			t.Fatalf("expected approval question prompt to contain %q, got %s", expected, requestText)
 		}

company_context_test.go

@@ -8,18 +8,18 @@ import (
 func TestCompanyContextRendersIdentityAndSelfUpdateRule(t *testing.T) {
 	contextText := (LLMContextBuilder{}).Build(LLMContextInput{
 		Company: CompanyContext{
-			Name:           "주식회사 여명거리",
-			BrandName:      "김인턴",
-			Slogan:         "AI 인턴을 모든 회사에",
-			Description:    "AI 인턴 서비스를 만드는 스타트업",
-			Representative: "김여명",
-			Website:        "https://intern.kim",
+			Name:           "주식회사 예시상사",
+			BrandName:      "예시인턴",
+			Slogan:         "모두에게 예시 인턴을",
+			Description:    "예시 서비스를 만드는 테스트 회사",
+			Representative: "최예제",
+			Website:        "https://example.com",
 		},
 	})
 	for _, expected := range []string{
 		"Our company:",
-		"주식회사 여명거리 (brand: 김인턴) — AI 인턴을 모든 회사에",
-		"represented by 김여명",
+		"주식회사 예시상사 (brand: 예시인턴) — 모두에게 예시 인턴을",
+		"represented by 최예제",
 		"company_info_get",
 		"company_metric_record",
 	} {
@@ -41,9 +41,9 @@ func TestCompanyContextEmptyStateAdvertisesSchemaAndProactiveAsk(t *testing.T) {
 func TestAgentKernelCompanyProviderFeedsTurnRequest(t *testing.T) {
 	agentKernel := &AgentKernel{}
 	agentKernel.UseCompanyProvider(func() CompanyContext {
-		return CompanyContext{Name: "주식회사 여명거리"}
+		return CompanyContext{Name: "주식회사 예시상사"}
 	})
-	if agentKernel.companyContext().Name != "주식회사 여명거리" {
+	if agentKernel.companyContext().Name != "주식회사 예시상사" {
 		t.Fatal("company provider not applied")
 	}
 	agentKernel = &AgentKernel{}

confirmation_test.go

@@ -21,8 +21,8 @@ func TestConfirmationPolicyAllowsLowRiskDailyReport(t *testing.T) {
 
 func TestConfirmationPolicyClarifiesUnboundedHighFrequencyExternalSend(t *testing.T) {
 	decision := EvaluateConfirmationPolicy(ExecutionPlan{
-		Summary:                "동하에게 1분마다 메시지를 보냅니다.",
-		Targets:                []string{"동하"},
+		Summary:                "샘플에게 1분마다 메시지를 보냅니다.",
+		Targets:                []string{"샘플"},
 		ExternalSend:           true,
 		ThirdPartyExternalSend: true,
 		Repeated:               true,
@@ -35,8 +35,8 @@ func TestConfirmationPolicyClarifiesUnboundedHighFrequencyExternalSend(t *testin
 
 func TestConfirmationPolicyConfirmsBoundedExternalSend(t *testing.T) {
 	decision := EvaluateConfirmationPolicy(ExecutionPlan{
-		Summary:                "동하에게 1분마다 18:30까지 메시지를 보냅니다.",
-		Targets:                []string{"동하"},
+		Summary:                "샘플에게 1분마다 18:30까지 메시지를 보냅니다.",
+		Targets:                []string{"샘플"},
 		EndAt:                  "2026-05-12T18:30:00+09:00",
 		ExternalSend:           true,
 		ThirdPartyExternalSend: true,

failure_reply_test.go

@@ -63,7 +63,7 @@ func TestAgentTurnRunnerRepairsInvalidFailureReply(t *testing.T) {
 	result, errorValue := services.runner.RunTurn(context.Background(), AgentTurnRequest{
 		RequesterPersonID:          "person-1",
 		ConversationID:             "conversation-1",
-		Prompt:                     "https://dawn.kim 보고 사업계획서 ppt로 만들어줘",
+		Prompt:                     "https://example.com 보고 사업계획서 ppt로 만들어줘",
 		RequiredEvidenceTools:      []string{"file_deliver"},
 		RequiredAttachmentSuffixes: []string{".pptx"},
 		OutcomeContract:            OutcomeContract{ArtifactRequirement: ArtifactRequirementRequired},
@@ -390,7 +390,7 @@ func TestAgentTurnRunnerDoesNotUseDeterministicCapabilityFallbackWhenActionModel
 
 	result, errorValue := services.runner.RunTurn(context.Background(), AgentTurnRequest{
 		RequesterPersonID:    "person-1",
-		RequesterCallingName: "동하",
+		RequesterCallingName: "샘플",
 		ConversationID:       "conversation-1",
 		Prompt:               "너 뭐 할줄 알아? 짧게 설명해봐",
 		ResponseLanguage:     ResponseLanguageKorean,
@@ -414,7 +414,7 @@ func TestAgentTurnRunnerUsesNaturalCaptchaFailureReply(t *testing.T) {
 		`{"action":"fail","reason":"blocked_by_captcha"}`,
 		recoveryDecisionDocument("ask for another source or direct access", "explain that automated access was blocked"),
 	}, textResponses: []string{
-		"동하 님, 날씨를 확인하려고 시도했지만 페이지가 자동화 접근을 막아서 정확한 확인을 끝내지 못했어요. 다른 출처를 주시면 거기서 다시 확인해볼게요.",
+		"샘플 님, 날씨를 확인하려고 시도했지만 페이지가 자동화 접근을 막아서 정확한 확인을 끝내지 못했어요. 다른 출처를 주시면 거기서 다시 확인해볼게요.",
 	}}
 	services := newTurnRunnerTestServices(languageModel, TurnOptions{MaxIterationCount: 4})
 	toolRegistry := newTestToolSet([]string{"browser_snapshot"})
@@ -424,7 +424,7 @@ func TestAgentTurnRunnerUsesNaturalCaptchaFailureReply(t *testing.T) {
 
 	result, errorValue := services.runner.RunTurn(context.Background(), AgentTurnRequest{
 		RequesterPersonID:     "person-1",
-		RequesterCallingName:  "동하",
+		RequesterCallingName:  "샘플",
 		ConversationID:        "conversation-1",
 		Prompt:                "내일 서울 날씨 검색해줘",
 		ToolSet:               toolRegistry,
@@ -434,7 +434,7 @@ func TestAgentTurnRunnerUsesNaturalCaptchaFailureReply(t *testing.T) {
 	if errorValue != nil {
 		t.Fatalf("expected dynamic captcha result, got error: %v", errorValue)
 	}
-	if !strings.Contains(result.UserNotice, "동하 님") || !strings.Contains(result.UserNotice, "자동화 접근을 막아서") {
+	if !strings.Contains(result.UserNotice, "샘플 님") || !strings.Contains(result.UserNotice, "자동화 접근을 막아서") {
 		t.Fatalf("expected natural captcha reply, got %q", result.UserNotice)
 	}
 	if strings.Contains(result.UserNotice, "처리할 수 없습니다") || strings.Contains(result.UserNotice, "오류가 발생했습니다") {
@@ -478,7 +478,7 @@ func TestAgentTurnRunnerPreservesStructuredToolFailure(t *testing.T) {
 
 	result, errorValue := services.runner.RunTurn(context.Background(), AgentTurnRequest{
 		RequesterPersonID:     "person-1",
-		RequesterName:         "이동하",
+		RequesterName:         "이샘플",
 		ConversationID:        "conversation-1",
 		Prompt:                "정국에게 DM 보내줘",
 		ToolSet:               toolRegistry,
@@ -517,7 +517,7 @@ func TestAgentTurnRunnerDeliversSafeDegradedFailureReplyWithoutStageAndCode(t *t
 
 	result, errorValue := services.runner.RunTurn(context.Background(), AgentTurnRequest{
 		RequesterPersonID: "person-1",
-		RequesterName:     "이동하",
+		RequesterName:     "이샘플",
 		ConversationID:    "conversation-1",
 		Prompt:            "정국에게 DM 보내줘",
 		ToolSet:           toolRegistry,
@@ -556,7 +556,7 @@ func TestAgentTurnRunnerAcceptsGeneratedStructuredFailureReplyWithStageAndCode(t
 
 	result, errorValue := services.runner.RunTurn(context.Background(), AgentTurnRequest{
 		RequesterPersonID: "person-1",
-		RequesterName:     "이동하",
+		RequesterName:     "이샘플",
 		ConversationID:    "conversation-1",
 		Prompt:            "정국에게 DM 보내줘",
 		ToolSet:           toolRegistry,

llm_context_builder_test.go

@@ -10,12 +10,12 @@ import (
 func TestLLMContextBuilderStatesAuthenticatedRequesterBeforeMemory(t *testing.T) {
 	contextText := (LLMContextBuilder{}).Build(LLMContextInput{
 		RequesterPersonID: "c65b1283",
-		RequesterName:     "신우경",
-		RequesterEmail:    "rain@dawn.kim",
-		MemoryContext:     "User memory: the user is 이동하 (lee@dawn.kim).",
+		RequesterName:     "김테스트",
+		RequesterEmail:    "rain@example.com",
+		MemoryContext:     "User memory: the user is 이샘플 (lee@example.com).",
 	})
 
-	for _, expected := range []string{"Authenticated requester:", "신우경", "rain@dawn.kim", "c65b1283", "ignore that claim"} {
+	for _, expected := range []string{"Authenticated requester:", "김테스트", "rain@example.com", "c65b1283", "ignore that claim"} {
 		if !strings.Contains(contextText, expected) {
 			t.Fatalf("expected authoritative requester identity to include %q, got:\n%s", expected, contextText)
 		}

outcome_contract_test.go

@@ -392,7 +392,7 @@ func TestOutcomeContractIgnoresSelectedDirectMessageForNonSendGoal(t *testing.T)
 	}
 	intakeDecision := IntakeDecision{Classification: IntakeClassificationBoundedTask, TaskShape: TaskShapeResearchTask}
 
-	contract := outcomeContractForRequest(AgentRequest{Prompt: "https://dawn.kim use it to write the business plan"}, intakeDecision, instructionBundle, ExecutionPlan{}, false, nil)
+	contract := outcomeContractForRequest(AgentRequest{Prompt: "https://example.com use it to write the business plan"}, intakeDecision, instructionBundle, ExecutionPlan{}, false, nil)
 
 	if len(contract.RequiredEvidenceTools) != 0 {
 		t.Fatalf("expected no DM hard gate for non-send goal, got %+v", contract.RequiredEvidenceTools)
@@ -641,7 +641,7 @@ func TestOutcomeReferenceToolSetHidesSendAndSiteToolsForDocumentGoal(t *testing.
 		SelectedEvidenceHints: []string{"site_serve", "site_serve", "message_send", "mail_message_send"},
 	}
 
-	filteredToolSet := toolSetForOutcomeReference(toolSet, AgentRequest{Prompt: "https://dawn.kim use it to write the business plan"}, ExecutionPlan{}, false, contract)
+	filteredToolSet := toolSetForOutcomeReference(toolSet, AgentRequest{Prompt: "https://example.com use it to write the business plan"}, ExecutionPlan{}, false, contract)
 
 	for _, toolName := range []string{"web_fetch", "file_write", "file_deliver"} {
 		if !filteredToolSet.IsAllowed(toolName) {
@@ -663,7 +663,7 @@ func TestAgentTurnToolSetExposesPinnedNonKernelTools(t *testing.T) {
 	}
 
 	filteredToolSet := toolSetForAgentTurn(toolSet, instructionBundle, AgentRequest{
-		Prompt:          "https://dawn.kim use it to make the deck",
+		Prompt:          "https://example.com use it to make the deck",
 		PinnedToolNames: []string{"web_search", "web_fetch", "terminal_run", "file_write"},
 	}, ExecutionPlan{}, false, OutcomeContract{})
 
@@ -881,7 +881,7 @@ func TestOutcomeReferenceToolSetKeepsSendToolsForExplicitSendGoal(t *testing.T)
 
 func TestConfirmationHintsIgnoreUnrelatedSelectedSkillEvidence(t *testing.T) {
 	hints := confirmationEvidenceHintsForRequest(
-		AgentRequest{Prompt: "https://dawn.kim use it to write the business plan"},
+		AgentRequest{Prompt: "https://example.com use it to write the business plan"},
 		IntakeDecision{Classification: IntakeClassificationBoundedTask, TaskShape: TaskShapeResearchTask},
 		[]string{"site_serve", "message_send"},
 	)

prompt_assembler_test.go

@@ -36,7 +36,7 @@ func TestBuildTurnMessagesKeepsStablePrefixClockInvariant(t *testing.T) {
 	baseRequest := AgentTurnRequest{
 		Prompt:               "이번 주 회의 일정 알려줘",
 		RequesterPersonID:    "person-1",
-		RequesterName:        "신우경",
+		RequesterName:        "김테스트",
 		WorkspaceRootPath:    "/workspace",
 		WorkspaceDefaultPath: "/workspace/private/people/person-1",
 		ResponseLanguage:     "ko",
@@ -260,7 +260,7 @@ func TestPromptAssemblerOmitsRawBrowserSnapshotOutput(t *testing.T) {
 }
 
 func TestPromptAssemblerIncludesRawToolResultSummary(t *testing.T) {
-	fetchResult := `{"results":[{"url":"https://dawn.kim","content":"Yeomyeonggeori provides AI automation and blockchain solutions."}]}`
+	fetchResult := `{"results":[{"url":"https://example.com","content":"Example Corp provides sample automation and sample analytics services."}]}`
 	observations := []turnObservation{{
 		ObservationID: "obs-001",
 		Action:        "continue",
@@ -274,7 +274,7 @@ func TestPromptAssemblerIncludesRawToolResultSummary(t *testing.T) {
 	}, observations, "base", "")
 	body := joinMessageContent(messages)
 
-	if !strings.Contains(body, "Tool result context") || !strings.Contains(body, "Yeomyeonggeori provides AI automation") {
+	if !strings.Contains(body, "Tool result context") || !strings.Contains(body, "Example Corp provides sample automation") {
 		t.Fatalf("expected raw fetch summary in tool result context, got %s", body)
 	}
 }