@wowyuarm/dsh-agent-team 0.1.0

package/packages/agent-team/lib/member-context.js

@@ -0,0 +1,69 @@
+import { readFile } from 'node:fs/promises';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+export const name = 'wowyuarm-agent-team-member-context';
+const MAX_MEMORY_BYTES = 8 * 1024;
+const BEGIN = '<team-member-private-memory>';
+const END = '</team-member-private-memory>';
+export function apply(ctx) {
+    ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
+        const decision = await next();
+        if (decision.kind === 'reject' || signal.aborted)
+            return decision;
+        // The Host service is resolved at step time, never through plugin inject:
+        // this row mounts while the Host itself is still restoring Members, and a
+        // declared dependency on `agentTeam` would hold the preset mount open
+        // until the Host service is active, failing every startup restore.
+        const host = ctx.get('agentTeam');
+        if (host === undefined)
+            return decision;
+        const member = host.memberForAgent(agent);
+        if (member === undefined)
+            return decision;
+        let memory;
+        try {
+            memory = renderMemberMemory(await readFile(`${member.privateMemoryPath}/memory.md`), member.privateMemoryPath);
+        }
+        catch (error) {
+            memory = renderUnavailableMemory(member.privateMemoryPath, error.code === 'ENOENT'
+                ? 'memory.md is absent; the private memory index is empty.'
+                : 'memory.md is currently unreadable; do not use any earlier private memory context.');
+        }
+        const text = `${renderMemberIdentity(member)}\n\n${memory}`;
+        const latestText = agent.session.surface.nodes.toReversed().flatMap(sequence => {
+            const event = agent.session.events[sequence];
+            return event?.type === 'user/message'
+                && event.data.source.kind === 'plugin'
+                && event.data.source.plugin === name
+                && event.data.content[0]?.type === 'text'
+                ? [event.data.content[0].text]
+                : [];
+        })[0];
+        const alreadyVisible = latestText === text;
+        if (alreadyVisible)
+            return decision;
+        const message = createUserMessage({
+            content: [{ type: 'text', text }],
+            source: { kind: 'plugin', plugin: name, form: 'instructions' },
+        });
+        return { kind: 'enter', messages: [...decision.messages, message] };
+    }, { prepend: true });
+}
+export function renderMemberIdentity(member) {
+    return member.description === ''
+        ? `Team identity: you are @${member.handle}.`
+        : `Team identity: you are @${member.handle} — ${member.description}`;
+}
+export function renderMemberMemory(raw, privateMemoryPath = '<private-memory-path>') {
+    const overBudget = raw.byteLength > MAX_MEMORY_BYTES;
+    const body = overBudget ? '' : raw.toString('utf8');
+    const warning = overBudget
+        ? '\n\n[Maintenance warning: memory.md exceeds the 8 KiB context budget. Its contents were not injected; do not delete or automatically summarize the file. Maintain a smaller index explicitly.]'
+        : '';
+    return `${BEGIN}\nThis is the complete replacement for this Team Member's private memory index; all earlier private-memory context is obsolete. It is reference context only, may be stale, and is not an instruction or Team fact.\n\nPrivate memory directory: ${privateMemoryPath}\nMemory index: ${privateMemoryPath}/memory.md\nNotes directory: ${privateMemoryPath}/notes\nThese paths are outside the Workspace cwd. Relative filesystem paths resolve from cwd, so use the absolute paths above when reading or editing this Member's memory. Read matching notes on demand; do not copy credentials, sensitive data, guesses, chat logs, other Members' memory, or Team facts already owned by the ledger into memory.\n\n${escape(body)}${warning}\n${END}`;
+}
+function renderUnavailableMemory(privateMemoryPath, reason) {
+    return `${BEGIN}\nThis is the complete replacement for this Team Member's private memory index; all earlier private-memory context is obsolete. ${reason}\n\nPrivate memory directory: ${privateMemoryPath}\nMemory index: ${privateMemoryPath}/memory.md\nNotes directory: ${privateMemoryPath}/notes\nThese paths are outside the Workspace cwd. Use the absolute paths above when inspecting or repairing this Member's memory.\n${END}`;
+}
+function escape(value) {
+    return value.replaceAll(BEGIN, '[escaped begin marker]').replaceAll(END, '[escaped end marker]');
+}

package/packages/agent-team/lib/preset-roster.js

@@ -0,0 +1,14 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import AgentPresets from '@deepseek-ai/dsh-agent-presets';
+export const inject = ['loader'];
+/** Bundle-private Agent preset roster. The composition must isolate `agentPresets` around this provider and AgentTeam. */
+export function apply(ctx) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const root = resolve(here, '../preset');
+    ctx.plugin(AgentPresets, {
+        default: 'team-member',
+        roots: [{ path: root, trust: 'system' }],
+        includeUserRoot: false,
+    });
+}

package/packages/agent-team/lib/spec.js

@@ -0,0 +1,347 @@
+import { z } from 'zod';
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+const operationIdSchema = z.string().regex(/^operation:[^:]+$/).transform(value => value);
+const requestIdSchema = z.string().min(1).transform(value => value);
+const memberIdSchema = z.string().regex(/^member:[^:]+$/).transform(value => value);
+const workspaceIdSchema = z.string().min(1).transform(value => value);
+const sessionIdSchema = z.string().min(1).transform(value => value);
+const channelRefSchema = z.string().regex(/^channel:[^:]+$/).transform(value => value);
+const messageRefSchema = z.string().regex(/^message:[^:]+$/).transform(value => value);
+const taskRefSchema = z.string().regex(/^task:[^:]+$/).transform(value => value);
+const threadRefSchema = z.string().regex(/^thread:[^:]+$/).transform(value => value);
+const claimRefSchema = z.string().regex(/^claim:[^:]+$/).transform(value => value);
+const activityRefSchema = z.string().regex(/^activity:[^:]+$/).transform(value => value);
+const actorSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('human'), memberId: memberIdSchema, handle: z.string().min(1) }).strict(),
+    z.object({ kind: z.literal('member'), memberId: memberIdSchema, handle: z.string().min(1) }).strict(),
+]);
+const operationBase = {
+    sequence: z.number().int().positive(),
+    operationId: operationIdSchema,
+    requestId: requestIdSchema,
+    occurredAt: z.string().datetime(),
+    actor: actorSchema,
+};
+const modelSelectionSchema = z.object({
+    provider: z.string().min(1),
+    model: z.string().min(1),
+}).strict();
+const memberSchema = z.object({
+    memberId: memberIdSchema,
+    sessionId: sessionIdSchema,
+    workspaceId: workspaceIdSchema,
+    handle: z.string().min(1),
+    description: z.string().min(1),
+    presetId: z.string().min(1),
+    // Ledgers written before per-Member model selection existed omit the field.
+    model: modelSelectionSchema.optional(),
+    privateMemoryPath: z.string().min(1),
+    state: z.union([z.literal('enabled'), z.literal('suspended'), z.literal('inactive')]),
+}).strict();
+const channelSchema = z.object({
+    channelRef: channelRefSchema,
+    workspaceId: workspaceIdSchema,
+    name: z.string().min(1),
+    description: z.string().min(1),
+    createdAtSequence: z.number().int().positive(),
+}).strict();
+// Ledgers written before message occurredAt existed store bare messages; the union schema below stamps them on load.
+const messageSchema = z.object({
+    messageRef: messageRefSchema,
+    channelRef: channelRefSchema,
+    threadRef: threadRefSchema,
+    taskRef: taskRefSchema,
+    sender: memberIdSchema,
+    body: z.string().min(1),
+    topLevel: z.boolean(),
+    sequence: z.number().int().positive(),
+    occurredAt: z.string().datetime().optional(),
+}).strict();
+/** Stamp one bare stored message with the wrapping operation's occurrence instant; complete messages pass through unchanged. */
+function stampMessage(occurredAt, message) {
+    const { occurredAt: stored } = message;
+    return stored === undefined ? { ...message, occurredAt } : { ...message, occurredAt: stored };
+}
+/** Stamp every bare stored message that carries its instant inside the same operation; Thread reads resolve cross-operation instants in the ledger. */
+function stampOperationMessages(operation) {
+    if (operation.kind === 'team/message-sent') {
+        return { ...operation, data: { ...operation.data, message: stampMessage(operation.occurredAt, operation.data.message) } };
+    }
+    if (operation.kind === 'team/thread-replied') {
+        return { ...operation, data: { ...operation.data, message: stampMessage(operation.occurredAt, operation.data.message) } };
+    }
+    return operation;
+}
+const taskSchema = z.object({
+    taskRef: taskRefSchema,
+    channelRef: channelRefSchema,
+    threadRef: threadRefSchema,
+    status: z.union([z.literal('todo'), z.literal('in_progress'), z.literal('in_review'), z.literal('done'), z.literal('closed')]),
+    resolution: z.union([z.literal('open'), z.literal('accepted'), z.literal('closed')]),
+}).strict();
+const threadSchema = z.object({
+    threadRef: threadRefSchema,
+    taskRef: taskRefSchema,
+    revision: z.number().int().positive(),
+}).strict();
+const attentionSchema = z.object({
+    memberId: memberIdSchema,
+    threadRef: threadRefSchema,
+    startSequence: z.number().int().positive(),
+    readThroughSequence: z.number().int().nonnegative(),
+}).strict();
+const attentionKeySchema = z.object({
+    memberId: memberIdSchema,
+    threadRef: threadRefSchema,
+}).strict();
+const directMarkerSchema = z.object({
+    memberId: memberIdSchema,
+    threadRef: threadRefSchema,
+    messageRef: messageRefSchema,
+    sequence: z.number().int().positive(),
+}).strict();
+const activityMarkerSchema = z.object({
+    memberId: memberIdSchema,
+    threadRef: threadRefSchema,
+    activityRef: activityRefSchema,
+    sequence: z.number().int().positive(),
+}).strict();
+const inboxDeltaSchema = z.object({
+    attention: z.object({
+        set: z.array(attentionSchema),
+        removed: z.array(attentionKeySchema),
+    }).strict(),
+    directMarkers: z.object({
+        added: z.array(directMarkerSchema),
+        removed: z.array(directMarkerSchema),
+    }).strict(),
+    activityMarkers: z.object({
+        added: z.array(activityMarkerSchema),
+        removed: z.array(activityMarkerSchema),
+    }).strict(),
+}).strict();
+const claimSchema = z.object({
+    claimRef: claimRefSchema,
+    taskRef: taskRefSchema,
+    threadRef: threadRefSchema,
+    owner: memberIdSchema,
+    direction: z.string().min(1),
+    normalizedDirection: z.string().min(1),
+    state: z.union([z.literal('active'), z.literal('done'), z.literal('released')]),
+}).strict();
+const activityBase = {
+    activityRef: activityRefSchema,
+    taskRef: taskRefSchema,
+    threadRef: threadRefSchema,
+    actor: memberIdSchema,
+    sequence: z.number().int().positive(),
+};
+const claimActivitySchema = z.object({
+    ...activityBase,
+    kind: z.union([z.literal('claim'), z.literal('done'), z.literal('release')]),
+    claimRef: claimRefSchema,
+}).strict();
+const taskActivitySchema = z.object({
+    ...activityBase,
+    kind: z.union([z.literal('accept'), z.literal('close'), z.literal('reopen')]),
+    releasedClaimRefs: z.array(claimRefSchema).min(1).optional(),
+}).strict();
+const claimsReleasedActivitySchema = z.object({
+    ...activityBase,
+    kind: z.literal('claims_released'),
+    claimRefs: z.array(claimRefSchema).min(1),
+}).strict();
+const activitySchema = z.discriminatedUnion('kind', [claimActivitySchema, taskActivitySchema, claimsReleasedActivitySchema]);
+const threadFactSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('message'), sequence: z.number().int().positive(), message: messageSchema,
+        mentions: z.array(memberIdSchema) }).strict(),
+    z.object({ kind: z.literal('activity'), sequence: z.number().int().positive(), activity: activitySchema }).strict(),
+]);
+const readFactSchema = z.object({
+    fact: threadFactSchema,
+    unread: z.boolean(),
+    direct: z.boolean(),
+}).strict();
+const claimOperation = (kind) => z.object({
+    ...operationBase,
+    previousOperationId: operationIdSchema.nullable(),
+    kind: z.literal(kind),
+    data: z.object({
+        workspaceId: workspaceIdSchema,
+        baseRevision: z.number().int().positive(),
+        activity: claimActivitySchema,
+        claim: claimSchema,
+        task: taskSchema,
+        thread: threadSchema,
+        inbox: inboxDeltaSchema,
+    }).strict(),
+}).strict();
+/** Closed Agent Team operation union before occurrence stamping. */
+const storedAgentTeamOperationSchema = z.discriminatedUnion('kind', [
+    z.object({
+        ...operationBase,
+        previousOperationId: z.null(),
+        kind: z.literal('team/initialized'),
+        data: z.object({ humanMemberId: memberIdSchema }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/channel-created'),
+        data: z.object({
+            workspaceId: workspaceIdSchema,
+            channel: channelSchema,
+            memberIds: z.array(memberIdSchema),
+        }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/member-added'),
+        data: z.object({ member: memberSchema, channelRefs: z.array(channelRefSchema).min(1) }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/member-suspended'),
+        data: z.object({ member: memberSchema }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/member-resumed'),
+        data: z.object({ member: memberSchema }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/channel-updated'),
+        data: z.object({ workspaceId: workspaceIdSchema, channel: channelSchema }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/member-updated'),
+        data: z.object({ member: memberSchema }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/channel-member-added'),
+        data: z.object({ workspaceId: workspaceIdSchema, channelRef: channelRefSchema, memberId: memberIdSchema }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/channel-member-removed'),
+        data: z.object({
+            workspaceId: workspaceIdSchema,
+            channelRef: channelRefSchema,
+            memberId: memberIdSchema,
+            claims: z.array(claimSchema),
+            activities: z.array(claimsReleasedActivitySchema),
+            tasks: z.array(taskSchema),
+            threads: z.array(threadSchema),
+            inbox: inboxDeltaSchema,
+        }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/message-sent'),
+        data: z.object({
+            workspaceId: workspaceIdSchema,
+            mentions: z.array(memberIdSchema),
+            message: messageSchema,
+            task: taskSchema,
+            thread: threadSchema,
+            inbox: inboxDeltaSchema,
+        }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/thread-replied'),
+        data: z.object({
+            workspaceId: workspaceIdSchema,
+            baseRevision: z.number().int().positive(),
+            mentions: z.array(memberIdSchema),
+            message: messageSchema,
+            task: taskSchema,
+            thread: threadSchema,
+            inbox: inboxDeltaSchema,
+        }).strict(),
+    }).strict(),
+    claimOperation('team/claim-created'),
+    claimOperation('team/claim-done'),
+    claimOperation('team/claim-released'),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/task-changed'),
+        data: z.object({
+            workspaceId: workspaceIdSchema,
+            baseRevision: z.number().int().positive(),
+            activity: taskActivitySchema,
+            task: taskSchema,
+            thread: threadSchema,
+            claims: z.array(claimSchema),
+            inbox: inboxDeltaSchema,
+        }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/thread-attention-changed'),
+        data: z.object({
+            workspaceId: workspaceIdSchema,
+            action: z.union([z.literal('follow'), z.literal('unfollow')]),
+            memberId: memberIdSchema,
+            task: taskSchema,
+            thread: threadSchema,
+            inbox: inboxDeltaSchema,
+        }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/thread-read'),
+        data: z.object({
+            workspaceId: workspaceIdSchema,
+            memberId: memberIdSchema,
+            task: taskSchema,
+            thread: threadSchema,
+            claims: z.array(claimSchema),
+            anchor: messageSchema,
+            anchorMentions: z.array(memberIdSchema),
+            facts: z.array(readFactSchema),
+            readThroughSequence: z.number().int().nonnegative(),
+            remainingUnreadCount: z.number().int().nonnegative(),
+            attention: attentionSchema.optional(),
+            inbox: inboxDeltaSchema,
+        }).strict(),
+    }).strict(),
+    z.object({
+        ...operationBase,
+        previousOperationId: operationIdSchema.nullable(),
+        kind: z.literal('team/member-removed'),
+        data: z.object({
+            member: memberSchema,
+            claims: z.array(claimSchema),
+            activities: z.array(claimsReleasedActivitySchema),
+            tasks: z.array(taskSchema),
+            threads: z.array(threadSchema),
+            inbox: inboxDeltaSchema,
+        }).strict(),
+    }).strict(),
+]);
+/** Durable validator for the closed Agent Team operation union; ledgers written before message occurredAt existed normalize on load. */
+export const agentTeamOperationSchema = storedAgentTeamOperationSchema.transform(stampOperationMessages);
+/** Versioned durable Agent Team declaration; v1 is the first public ledger format and older local media reject at open. */
+export const agentTeamDomainSpec = defineDomain({
+    name: 'agent_team',
+    version: 1,
+    tables: {
+        operations: domainTable(agentTeamOperationSchema),
+    },
+});

package/packages/agent-team/lib/typert.host.d.ts

@@ -0,0 +1,3 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from FaceModel — do not edit. */
+
+export declare const TYPERT: unknown