Files
archie/internal/domain/messaging/inbound.go
T
sam c70fb61bfc fix(gateway): stamp the session platform from the channel that carried the message
One Router serves every channel and named itself "web", so Source.Platform -- the
FIRST component of the session natural key, and the platform GetByChannel filters
on -- was a constant, true of no channel but the dashboard. Two consequences
followed: the per-user identity policy was real code that no production call site
reached with a real channel name, and a curator pass's write to agent-user memory
could not be read back by the turn that wrote it, because that turn resolved no
UserID.

The channel now travels with the message. Frontends name the channel they carry
(pb.Message.platform: telegram, email, webhook, web), and the Gateway stamps the
session from it, falling back to its own name when a sender names none -- which is
what every existing row holds and what a frontend that does not participate keeps
doing.

Identity resolution reads the platform off the inbound rather than closing over a
channel name, so carriesPersonIdentity finally decides something in production:
telegram and email resolve a person, the dashboard and a webhook resolve nothing,
and an unknown platform fails closed.

Deliberately NOT changed, because it is where this could quietly widen scope:
TurnRunnerConfig.Channel still keys tool availability, so no channel gains or
loses a tool here. Only session lookup and identity follow the message's platform.

Consequence the maintainer accepted: a chat whose active session came from /new or
/branch re-resolves once, since GetByChannel now filters on the channel's name. A
chat with no /new re-resolves onto the same deterministic session id and heals
silently.

Verified: gateway, archied, gatewayrpc, messaging, webui, channels and cmd suites,
go vet ./..., go build ./..., golangci-lint run ./... (0 issues), docs:check.
New contracts: TestResolveSessionKeyStampsTheMessagesPlatform, the per-platform
identity table, and the transport-context wire round trip.
2026-09-22 04:30:15 +10:00

87 lines
3.9 KiB
Go

package messaging
import (
"context"
"time"
)
// Inbound is a message arriving from a channel together with the
// transport context that is not part of the canonical record.
//
// Message is the record itself, exactly as it will be persisted. Channels
// construct it directly: ConversationID addresses the chat (a Telegram
// chat ID and topic thread, an email recipient, a webhook path), Sender is
// the channel-native attribution, and Role is always RoleUser --
// a channel only ever carries what a person said. ID is left empty for a
// newly received message so the store derives one from SourceID, and
// honoured when set, which is what lets a read-modify-write of a history
// keep its identities rather than minting new ones.
type Inbound struct {
Message Message
// Page is the dashboard route the operator is on when they sent
// this message. Transport-only: it reaches the system prompt and
// is never persisted. Empty for non-web channels.
Page string
// BudgetKey is what the Gateway charges this message against in its
// inbound rate limiter (internal/ratelimit), for a channel whose
// Message.SenderID is empty because it carries no per-person
// identity but still has a stable, operator-controlled source to
// budget -- a webhook's configured route path, today. It is
// deliberately not SenderID: SenderID means "this is who sent it",
// and several consumers (internal/app/archied/chat_identity.go,
// sessioncurator) read it as a person, so a route path in that field
// becomes a user identity. BudgetKey is transport-only and never
// persisted, exactly like Page. Empty means the message is not
// rate limited, which is correct for a source with no stable key of
// its own (the dashboard).
BudgetKey string
// Platform is the channel that carried this message ("telegram",
// "email", "webhook", "web"), named by the frontend that owns that
// channel. It is how the Gateway learns which channel it is serving:
// one Router serves all of them, so its own name is "web" even for a
// Telegram turn, which made SessionSource.Platform -- the first
// component of the session natural key -- a constant, and left the
// per-user identity policy unreachable with a real channel name
// (archie-core-c1qx). Transport-only and never persisted: the session
// record keeps the platform. Empty means the sender did not name its
// channel, and the Gateway falls back to its own name.
Platform string
}
// SpawnRequest is a chat-originated task creation request. Repo and
// Workflow are optional -- empty means "the daemon's configured
// default for this identity".
type SpawnRequest struct {
Title string
Body string // operator instructions carried into the admitted task
Repo string // "owner/name"; empty = identity's default repo
Workflow string // empty = daemon's default workflow routing
Identity string // the identity spawning this task; propagated from Router.Identity
}
// TaskCreator creates a native (non-forge-backed) task from a chat
// command. The daemon supplies an implementation backed by the store.
// When nil on a Router, /spawn returns "not configured". CreateTask
// must return the task's real, durable database ID -- never a
// synthetic or fabricated value.
type TaskCreator interface {
CreateTask(ctx context.Context, req SpawnRequest) (taskID int64, err error)
}
// DangerousCommandAuthority is the sandbox-owned authority for operations
// that can destroy process or filesystem state. Adapters only request and
// present approval; they never implement these operations themselves.
type DangerousCommandAuthority interface {
StopProcess(context.Context, string) error
Rollback(context.Context, int) (string, error)
ListCheckpoints(context.Context) ([]CheckpointInfo, error)
}
// CheckpointInfo describes a saved sandbox filesystem checkpoint.
type CheckpointInfo struct {
Number int
Timestamp time.Time
Label string
Size string
}